diff -r 000000000000 -r e686773b3f54 phonebookengines/contactsmodel/tsrc/Integration/CntPerfTest/src/ContactUtilitiesCollection.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phonebookengines/contactsmodel/tsrc/Integration/CntPerfTest/src/ContactUtilitiesCollection.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,2688 @@ +// 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 "ContactUtilitiesCollection.h" +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include "cntdb_internal.h" +#endif + +/** + * Destructor + */ +CContactUtilitiesCollection::~CContactUtilitiesCollection() + { + } + + +/** + * Constructor + */ +CContactUtilitiesCollection* CContactUtilitiesCollection::NewL(CTestStep& aTestStep, CContactDatabase& aDb, CContactViewCollection& aViewCollection) + { + CContactUtilitiesCollection* self = new(ELeave) CContactUtilitiesCollection(aTestStep, aDb, aViewCollection); + return self; + } + +/** + * Return database reference + * @return CContactDatabase& + */ +CContactDatabase& CContactUtilitiesCollection::DatabaseReference() + { + return iDb; + } + +/** + * Return viewcollection reference + * @return CContactViewCollection& + */ +CContactViewCollection& CContactUtilitiesCollection::ViewCollectionReference() + { + return iViewCollection; + } + + +/** + * Constructor + */ +CContactUtilitiesCollection::CContactUtilitiesCollection(CTestStep& aTestStep, CContactDatabase& aDb, CContactViewCollection& aViewCollection) +: iBaseTestStep(aTestStep), iDb(aDb), iViewCollection(aViewCollection) + { + } + +/** + * Gets a reference to the base test step. This is needed to read from the ini file + * @return CTestStep& + */ +CTestStep& CContactUtilitiesCollection::BaseTestStepReference() + { + return iBaseTestStep; + } + +/** +* Get the data required for the construction of the local view from the ini file and call the function +* ConstructLocalViewL to construct a local view Object. +* @param aSection ini section +*/ +void CContactUtilitiesCollection::GetDataAndConstructLocalViewL(const TDesC& aSection) + { + TPtrC viewSortOrder; + TPtrC viewPreferences; + TPtrC localViewSortPlugin; + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KViewSortOrder, viewSortOrder); + BaseTestStepReference().GetStringFromConfig(aSection, KViewPreferences, viewPreferences); + BaseTestStepReference().GetStringFromConfig(aSection, KLocalViewSortPlugin, localViewSortPlugin); + + // Construct the local view by passing the input data required for the construction + ConstructLocalViewL(viewSortOrder, viewPreferences, localViewSortPlugin, viewNotReady); + } + +/* +* Allocate and construct a local view object based on the sortorder, view preferences, sortplug-in given from the +* ini file +* @param aSortOrder specifies the fields to use to sort the items in the view +* @param aViewPreferences specifies the type of the contact item to be included in the view +* @param aSortPlugin specifies a plug-in that will be used to compare view contacts when the view is sorted +*/ +void CContactUtilitiesCollection::ConstructLocalViewL(const TDesC& aSortOrder, const TDesC& aViewPreferences, const TDesC& aSortPlugin, + TBool aViewNotReady) + { + // Get Db and view collection reference + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + // Construct a view event queue object + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + + TContactViewPreferences viewPreferences = ConvertStringToContactViewPreferencesL(aViewPreferences); + RContactViewSortOrder sortOrder = ConvertStringToSortOrderL(aSortOrder); + CContactLocalView* localView = NULL; + // if sortplugin is specified in the ini, then create a local view object which contains sort plugin details. + if ( aSortPlugin != KNullDesC() ) + { + HBufC8* sortPlugin = HBufC8::NewLC(aSortPlugin.Length()); + sortPlugin->Des().Copy(aSortPlugin); + TRAPD( err, localView = CContactLocalView::NewL(*viewEventQueue, cDb, sortOrder, viewPreferences, sortPlugin->Des())); + if( err != KErrNone ) + { + BaseTestStepReference().ERR_PRINTF2(KErrSortPlugin, err); + BaseTestStepReference().SetTestStepError(err); + aViewNotReady = TRUE; + } + CleanupStack::Pop(sortPlugin); + } + else + { + localView = CContactLocalView::NewL(*viewEventQueue, cDb, sortOrder, viewPreferences); + } + + CleanupStack::PushL(localView); + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + if(localView!=NULL) + { + (cViewCollection.iArrayOfLocalViews).AppendL(localView); + (cViewCollection.iArrayOfLocalViewEvents).AppendL(viewEventQueue); + } + CleanupStack::Pop(localView); + CleanupStack::Pop(viewEventQueue); + } + +/* +* Get the data required for the construction of the remote view from the ini file and call the function +* ConstructRemoteViewL to construct a remote view Object. +* @param aSection ini section name +*/ +void CContactUtilitiesCollection::GetDataAndConstructRemoteViewL(const TDesC& aSection) + { + TPtrC viewSortOrder; + TPtrC viewPreferences; + TPtrC remoteViewSortPlugin; + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KViewSortOrder, viewSortOrder); + BaseTestStepReference().GetStringFromConfig(aSection, KViewPreferences, viewPreferences); + BaseTestStepReference().GetStringFromConfig(aSection, KRemoteViewSortPlugin, remoteViewSortPlugin); + + // Construct remote view by passing the data required for the construction + ConstructRemoteViewL(viewSortOrder, viewPreferences, remoteViewSortPlugin, viewNotReady); + } + +/* +* Allocate and construct a remote view object based on the sortorder, view preferences, sortplug-in given from the +* ini file +* @param aSortOrder Specifies the fields to use to sort the items in the view +* aram aViewPreferences Specifies the type of the contact item to be included in the view +* aram aSortPlugin Specifies a plug-in that will be used to compare view contacts when the view is sorted +*/ +void CContactUtilitiesCollection::ConstructRemoteViewL(const TDesC& aSortOrder, const TDesC& aViewPreferences, const TDesC& aSortPlugin, + TBool aViewNotReady) + { + TContactViewPreferences viewPreferences = ConvertStringToContactViewPreferencesL(aViewPreferences); + RContactViewSortOrder sortOrder = ConvertStringToSortOrderL(aSortOrder); + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + + CContactRemoteView* remoteView = NULL; + + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + if ( aSortPlugin != KNullDesC() ) + { + HBufC8* sortPlugin = HBufC8::NewLC(aSortPlugin.Length()); + sortPlugin->Des().Copy(aSortPlugin); + // Construct a remote view which contains sort plugin details. + TRAPD( err, remoteView = CContactRemoteView::NewL(*viewEventQueue, cDb, sortOrder, viewPreferences, sortPlugin->Des())); + CleanupStack::Pop(sortPlugin); + if( err != KErrNone ) + { + BaseTestStepReference().ERR_PRINTF2(KErrSortPlugin, err); + BaseTestStepReference().SetTestStepError(err); + aViewNotReady = TRUE; + } + } + else + { + remoteView = CContactRemoteView::NewL(*viewEventQueue, cDb, sortOrder, viewPreferences); + } + CleanupStack::PushL(remoteView); + + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + + // Append the remote view and remote view events in the array which will be used for testing + (cViewCollection.iArrayOfRemoteViewEvents).AppendL(viewEventQueue); + (cViewCollection.iArrayOfRemoteViews).AppendL(remoteView); + CleanupStack::Pop(remoteView); + CleanupStack::Pop(viewEventQueue); + } + +/* +* Get the data required for the construction of the named remote view from the ini file and call the function +* ConstructNamedRemoteView to construct a named remote view Object. +* @param aSection ini section name +*/ +void CContactUtilitiesCollection::GetDataAndConstructNamedRemoteViewL(const TDesC& aSection) + { + TPtrC name; + TPtrC viewSortOrder; + TPtrC viewPreferences; + TPtrC namedViewSortPlugin; + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KNamedRemoteViewName, name); + BaseTestStepReference().GetStringFromConfig(aSection, KViewSortOrder, viewSortOrder); + BaseTestStepReference().GetStringFromConfig(aSection, KViewPreferences, viewPreferences); + BaseTestStepReference().GetStringFromConfig(aSection, KNamedViewSortPlugin, namedViewSortPlugin); + + // Construct a named remote view by passing the data required for the construction + ConstructNamedRemoteViewL(name, viewSortOrder, viewPreferences, namedViewSortPlugin, viewNotReady); + } + +/* +* Allocate and construct a named remote view object based on the name, sortorder, view preferences, sortplug-in given from the +* ini file +* @param aName The name of the view object in the server +* @param aSortOrder specifies the fields to use to sort the items in the view +* @param aViewPreferences specifies the type of the contact item to be included in the view +* @param aSortPlugin specifies a plug-in that will be used to compare view contacts when the view is sorted +*/ +void CContactUtilitiesCollection::ConstructNamedRemoteViewL(const TDesC& aName, const TDesC& aSortOrder, const TDesC& aViewPreferences, + const TDesC& aSortPlugin, TBool aViewNotReady) + { + TContactViewPreferences viewPreferences = ConvertStringToContactViewPreferencesL(aViewPreferences); + RContactViewSortOrder sortOrder = ConvertStringToSortOrderL(aSortOrder); + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + HBufC* name = HBufC::NewLC(aName.Length()); + name->Des().Copy(aName); + CContactNamedRemoteView* namedRemoteView = NULL; + + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + + if ( aSortPlugin != KNullDesC() ) + { + HBufC8* sortPlugin = HBufC8::NewLC(aSortPlugin.Length()); + sortPlugin->Des().Copy(aSortPlugin); + // Construct a named remote view which contains sort plug-in details + TRAPD( err, namedRemoteView = CContactNamedRemoteView::NewL(*viewEventQueue, name->Des(), cDb, sortOrder, viewPreferences, sortPlugin->Des())); + CleanupStack::PopAndDestroy(sortPlugin); + if( err != KErrNone ) + { + BaseTestStepReference().ERR_PRINTF2(KErrSortPlugin, err); + BaseTestStepReference().SetTestStepError(err); + aViewNotReady = TRUE; + } + } + else + { + namedRemoteView = CContactNamedRemoteView::NewL(*viewEventQueue, name->Des(), cDb, sortOrder, viewPreferences); + } + CleanupStack::PushL(namedRemoteView); + + // If aViewNotReady is set to true then the view is not ready + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + if(namedRemoteView != NULL) + { + (cViewCollection.iArrayOfNamedRemoteViewEvents).AppendL(viewEventQueue); + // append the named remote view and named remote view events to the array which will be used for testing + (cViewCollection.iArrayOfNamedRemoteViews).AppendL(namedRemoteView); + } + CleanupStack::Pop(namedRemoteView); + CleanupStack::PopAndDestroy(name); + CleanupStack::Pop(viewEventQueue); + + } + +/* +* Get the data required for the construction of the find view from the ini file and call the function +* ConstructFindView to construct a find view Object. +* @param aSection ini section name +*/ +void CContactUtilitiesCollection::GetDataAndConstructFindViewL(const TDesC& aSection) + { + TPtrC searchWords; + TPtrC searchType; + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KSearchWords, searchWords); + BaseTestStepReference().GetStringFromConfig(aSection, KSearchType, searchType); + + // Get the underlying required view for the construction of find view + CContactViewBase* viewBase = GetDesiredView(aSection); + + // Construct a find view by passing the data required for the construction + ConstructFindViewL(searchWords, searchType, viewBase, viewNotReady); + } + +/* +* Allocate and constructs a find view object based on the search words and the search type given from the +* ini file +* @param aSearchWords The search terms +* @param aSortPlugin specifies a plug-in that will be used to compare view contacts when the view is sorted +* @param aSearchType The search type +* @param aViewBase underlying view +*/ +void CContactUtilitiesCollection::ConstructFindViewL(const TDesC& aSearchWords, const TDesC& aSearchType, + CContactViewBase* aViewBase, TBool aViewNotReady) + { + RArray searchList; + CleanupClosePushL(searchList); + TokenizeStringL(aSearchWords, searchList); + + // allocate an array to store the search words + CPtrCArray* findWords = new(ELeave) CPtrCArray(3); + CleanupStack::PushL(findWords); + for ( TInt i = 0; i < searchList.Count(); ++i ) + { + findWords->AppendL(searchList[i]); + } + + CContactViewBase::TSearchType searchType = GetSearchType(aSearchType); + // Construct an view event queue object + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + CContactFindView* findView; + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + if ( aSearchType != KNullDesC() ) + { + // Construct a find view which contains search type + findView = CContactFindView::NewL(cDb, *aViewBase, *viewEventQueue, findWords, searchType); + } + else + { + findView = CContactFindView::NewL(cDb, *aViewBase, *viewEventQueue, findWords); + } + CleanupStack::PushL(findView); + + // If aViewNotReady is set to true then the view is not ready + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + + // appends the find view and find view events to the array which will be used for testing + if(findView != NULL) + { + (cViewCollection.iArrayOfFindViewEvents).AppendL(viewEventQueue); + (cViewCollection.iArrayOfFindViews).AppendL(findView); + } + CleanupStack::Pop(findView); + CleanupStack::Pop(viewEventQueue); + CleanupStack::PopAndDestroy(findWords); + CleanupStack::PopAndDestroy(&searchList); + } + +/* +* Get the data required for the construction of the local view from the ini file and call the function +* ConstructGroupView to construct a group view Object. +* @param aSection ini section name +*/ +void CContactUtilitiesCollection::GetDataAndConstructGroupViewL(const TDesC& aSection) + { + TPtrC groupType; + TPtrC groupName; + TInt groupId = -1; + TBool viewNotReady = EFalse; + TInt groupViewVersion = 0; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KGroupType, groupType); + BaseTestStepReference().GetStringFromConfig(aSection, KGroupName, groupName); + BaseTestStepReference().GetIntFromConfig(aSection, KGroupId, groupId); + BaseTestStepReference().GetIntFromConfig(aSection, KGroupVersion, groupViewVersion); + + // Get the underlying view for the construction of group view + CContactViewBase* viewBase = GetDesiredView(aSection); + + // Construct the group view by passing the data required for the construction + ConstructGroupViewL(groupType, groupName, groupId, viewBase, viewNotReady, groupViewVersion); + } + +/* +* Allocate and construct a group view object based on the grouptype, groupid and groupname given from the +* ini file +* @param aGroupType The group Type +* @param aGroupName the group name +* @param aGroupId The Id of the contact group +* @param aViewBase underlying view +*/ +void CContactUtilitiesCollection::ConstructGroupViewL(const TDesC& aGroupType, const TDesC& aGroupName, const TInt& aGroupId, + CContactViewBase* aViewBase, TBool aViewNotReady, TInt& aGroupViewVersion) + { + // Get the group type required for the construction of group view + CContactGroupView::TGroupType groupType = GetGroupType(aGroupType); + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + CContactGroupView* groupView = NULL; + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + //Construct a group view using version 1 + if(aGroupViewVersion == 1) + { + if( aGroupName != KNullDesC() ) + { + // Construct a group view which contains the details of group name + TRAPD(err, groupView = CContactGroupView::NewL(cDb, *aViewBase, *viewEventQueue, aGroupName, groupType)); + if( err != KErrNone) + { + BaseTestStepReference().SetTestStepError(err); + BaseTestStepReference().SetTestStepResult(EFail); + aViewNotReady = ETrue; + } + } + if(aGroupId > 0) + { + TRAPD(err, groupView = CContactGroupView::NewL(cDb, *aViewBase, *viewEventQueue, aGroupId, groupType)); + if( err != KErrNone) + { + BaseTestStepReference().SetTestStepError(err); + BaseTestStepReference().SetTestStepResult(EFail); + aViewNotReady = ETrue; + } + } + } + else + {//Construct a group view using version 2 + if( aGroupName != KNullDesC() ) + { + // Construct a group view which contains the details of group name + TRAPD(err, groupView =CContactGroupView::NewL(*aViewBase, cDb, *viewEventQueue, aGroupName, groupType)); + if( err != KErrNone) + { + BaseTestStepReference().SetTestStepError(err); + BaseTestStepReference().SetTestStepResult(EFail); + aViewNotReady = ETrue; + } + } + if(aGroupId > 0) + { + TRAPD(err, groupView = CContactGroupView::NewL(*aViewBase, cDb, *viewEventQueue, aGroupId, groupType)); + if( err != KErrNone) + { + BaseTestStepReference().SetTestStepError(err); + BaseTestStepReference().SetTestStepResult(EFail); + aViewNotReady = ETrue; + } + } + + } + + CleanupStack::PushL(groupView); + + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + // append the group view to the array which will be used for multiple view access tests + if( groupView != NULL ) + { + (cViewCollection.iArrayOfGroupViews).AppendL(groupView); + (cViewCollection.iArrayOfGroupViewEvents).AppendL(viewEventQueue); + } + CleanupStack::Pop(groupView); + CleanupStack::Pop(viewEventQueue); + } + +/* +* Get the data required for the construction of the local view from the ini file and call the function +* ConstructFilteredView to construct a filtered view Object. +* @param aSection ini section name +*/ +void CContactUtilitiesCollection::GetDataAndConstructFilteredViewL(const TDesC& aSection) + { + TPtrC viewFilter; + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KViewFilter, viewFilter); + // Get the underlying view required for the construction of filtered view + CContactViewBase* viewBase = GetDesiredView(aSection); + + // construct the filtered view by passing the data required for the construction + ConstructFilteredViewL(viewFilter, viewBase, viewNotReady); + } + +/* +* Allocate and constructs a filter view object based on the filter type given from the +* ini file +* @param aViewFilter The filter to use. +* @param aViewBase underlying view +*/ +void CContactUtilitiesCollection::ConstructFilteredViewL(const TDesC& aViewFilter, CContactViewBase* aViewBase, TBool aViewNotReady) + { + // Get the filter type required for the construction of filtered view + CContactDatabase::TContactViewFilter viewFilter = GetContactViewFilterL(aViewFilter); + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + CContactFilteredView* filteredView = CContactFilteredView::NewL(*viewEventQueue, cDb, *aViewBase, viewFilter); + CleanupStack::PushL(filteredView); + + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + // append the filtered view and its events to the array which will be used for testing + if(filteredView !=NULL) + { + (cViewCollection.iArrayOfFilteredViews).AppendL(filteredView); + (cViewCollection.iArrayOfFilteredViewEvents).AppendL(viewEventQueue); + } + CleanupStack::Pop(filteredView); + CleanupStack::Pop(viewEventQueue); + } + +/* +* Get the data required for the construction of the local view from the ini file and call the function +* ConstructConcatenatedView to construct a concatenated view Object. +* @param aSection ini section +*/ +void CContactUtilitiesCollection::ConstructConcatenatedViewL(const TDesC& aSection) + { + // Get the component views required for the construction of concatenated views + RPointerArray& arrayOfViews = GetComponentViewsL(aSection); + CleanupClosePushL(arrayOfViews); + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + + CContactConcatenatedView* concatenatedView = CContactConcatenatedView::NewL(*viewEventQueue, cDb, arrayOfViews); + CleanupStack::PushL(concatenatedView); + + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + + if(!viewNotReady) + { + WaitForViewReady(viewEventQueue); + } + if(concatenatedView != NULL) + { + // append the concatenated view to the array which will be used for multiple view access tests + (cViewCollection.iArrayOfConcatenatedViews).AppendL(concatenatedView); + (cViewCollection.iArrayOfConcatenatedViewEvents).AppendL(viewEventQueue); + } + CleanupStack::Pop(concatenatedView); + CleanupStack::Pop(viewEventQueue); + CleanupStack::PopAndDestroy(&arrayOfViews); + + } + +/* +* Get the data required for the construction of the local view from the ini file and call the function +* ConstructSubView to construct a sub view Object. +* @param aSection ini section name +*/ +void CContactUtilitiesCollection::GetDataAndConstructSubViewL(const TDesC& aSection) + { + TPtrC lowerBoundary; + TPtrC higherBoundary; + TPtrC boundary; + TBool viewNotReady = EFalse; + BaseTestStepReference().GetBoolFromConfig(aSection, KViewNotReady, viewNotReady); + BaseTestStepReference().GetStringFromConfig(aSection, KLowerBoundary, lowerBoundary); + BaseTestStepReference().GetStringFromConfig(aSection, KHigherBoundary, higherBoundary); + BaseTestStepReference().GetStringFromConfig(aSection, KBoundary, boundary); + + // Get the underlying view required for the construction of the sub view + CContactViewBase* viewBase = GetDesiredView(aSection); + // Construct the sub view by passing the data from the ini file + ConstructSubViewL(lowerBoundary, higherBoundary, boundary, viewBase, viewNotReady); + } + +/* +* Allocate and constructs a sub view object based on the lower and higher boundary specified in the +* ini file +* @param aLowerBoundary A string containing the sub view's lower boundary criteria +* @param aHigherBoundary A string containing the sub view's higher boundary criteria +* @param aBoundary A string containing the sub-view criteria +* @param aViewBase underlying view +*/ +void CContactUtilitiesCollection::ConstructSubViewL(const TDesC& aLowerBoundary, const TDesC& aHigherBoundary, const TDesC& aBoundary, + CContactViewBase* aViewBase, TBool aViewNotReady) + { + CContactViewEventQueue* viewEventQueue = CContactViewEventQueue::NewL(); + CleanupStack::PushL(viewEventQueue); + CContactSubView* subView; + CContactDatabase& cDb = DatabaseReference(); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + + if ( aLowerBoundary != KNullDesC() || aHigherBoundary != KNullDesC() ) + { + // Construct a sub view which contains both the higher and lower boundary + subView = CContactSubView::NewL(*viewEventQueue, cDb, *aViewBase, aLowerBoundary, aHigherBoundary); + } + else + { + subView = CContactSubView::NewL(*viewEventQueue, cDb, *aViewBase, aBoundary); + } + CleanupStack::PushL(subView); + + if(!aViewNotReady) + { + WaitForViewReady(viewEventQueue); + } + if(subView != NULL) + { + // append the sub view to the array which will be used for multiple view access tests + (cViewCollection.iArrayOfSubViews).AppendL(subView); + (cViewCollection.iArrayOfSubViewEvents).AppendL(viewEventQueue); + } + CleanupStack::Pop(subView); + CleanupStack::Pop(viewEventQueue); + } + + +/* +* Get the underlying view type and index required for the views like find view, filtered view, group view, +* and sub view from the ini file and get the view of the specified type for that particular index +* @param aSection ini section +* @return CContactViewBase* +*/ +CContactViewBase* CContactUtilitiesCollection::GetDesiredView(const TDesC& aSection) + { + TPtrC viewBase; + TInt index = -1; + BaseTestStepReference().GetStringFromConfig(aSection, KViewBase, viewBase); + BaseTestStepReference().GetIntFromConfig(aSection, KIndexOfViews, index); + + CContactViewCollection& cViewCollection = ViewCollectionReference(); + CContactViewBase* contactViewBase = NULL; + // Based on the view type specified in the ini file, get the underlying view for the specified index + if ( viewBase.Compare(KLocalView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredLocalView(index); + } + else if ( viewBase.Compare(KRemoteView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredRemoteView(index); + } + else if ( viewBase.Compare(KNamedRemoteView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredNamedRemoteView(index); + } + else if ( viewBase.Compare(KFindView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredFindView(index); + } + else if ( viewBase.Compare(KFilteredView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredFilteredView(index); + } + else if ( viewBase.Compare(KGroupView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredGroupView(index); + } + else if ( viewBase.Compare(KConcatenatedView) == 0 ) + { + contactViewBase= cViewCollection.GetDesiredConcatenatedView(index); + } + else if ( viewBase.Compare(KSubView) == 0 ) + { + contactViewBase = cViewCollection.GetDesiredSubView(index); + } + return contactViewBase; + } + +/* +* Get the component views required for construction of the concatenated view. The component views can be of any view +* type like local view, remote view, named remote view, find view, filtered view, group view and sub view +* @param aSection ini section +* @return RPointerArray& +*/ +RPointerArray& CContactUtilitiesCollection::GetComponentViewsL(const TDesC& aSection) + { + TPtrC componentViews; + BaseTestStepReference().GetStringFromConfig(aSection, KComponentViews, componentViews); + CContactViewCollection& cViewCollection = ViewCollectionReference(); + TBuf field; + field.Zero(); + field.Append(KIndexOfView); + TInt indexOfView = -1; + + RArray views; + CleanupClosePushL(views); + TokenizeStringL(componentViews, views); + // Iterate through the list of component views given in the ini file + for ( TInt i = 0; i < views.Count(); ++i ) + { + field.AppendNum(i); + BaseTestStepReference().GetIntFromConfig(aSection, field, indexOfView); + CContactViewBase* viewBase; + // Append the view in the array iArrayofViewBase which is of type CContactViewBase + if ( views[i].Compare(KLocalView) == 0 ) + { + viewBase = cViewCollection.GetDesiredLocalView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KRemoteView) == 0 ) + { + viewBase = cViewCollection.GetDesiredRemoteView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KNamedRemoteView) == 0 ) + { + viewBase = cViewCollection.GetDesiredNamedRemoteView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KFindView) == 0 ) + { + viewBase = cViewCollection.GetDesiredFindView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KFilteredView) == 0 ) + { + viewBase = cViewCollection.GetDesiredFilteredView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KGroupView) == 0 ) + { + viewBase = cViewCollection.GetDesiredGroupView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KConcatenatedView) == 0 ) + { + viewBase = cViewCollection.GetDesiredConcatenatedView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + else if ( views[i].Compare(KSubView) == 0 ) + { + viewBase = cViewCollection.GetDesiredSubView(indexOfView); + (cViewCollection.iArrayOfViewBase).AppendL(viewBase); + } + } + CleanupStack::PopAndDestroy(&views); + return (cViewCollection.iArrayOfViewBase); + } + +/* +* Delete the database based on the boolean variable set in the ini file +* @param aDeleteDataBase Boolean value that decides to delete the database +* @param aDbName database name +*/ +void CContactUtilitiesCollection::DeleteDataBase(TBool aDeleteDataBase, const TDesC& aDbName) + { + // If aDeleteDataBase is set to true, then delete the database + if ( aDeleteDataBase ) + { + TRAPD(err, CContactDatabase::DeleteDatabaseL(aDbName) ); + if ( err != KErrNone ) + { + BaseTestStepReference().ERR_PRINTF1(KErrInDeleteDataBase); + BaseTestStepReference().SetTestStepError(err); + BaseTestStepReference().SetTestStepResult(EFail); + } + } + } + +/* +* Convert the string of type uid which is used for the construction of the views. Commonly used sort fields are only supported +* if more is required, can be added in the loop. +* @param aSortOrder sort order passed in the ini file +* @return RContactViewSortOrder +*/ +RContactViewSortOrder CContactUtilitiesCollection::ConvertStringToSortOrderL(const TDesC& aSortOrderString) + { + RContactViewSortOrder sortOrder; + RArray sortOrderList; + CleanupClosePushL(sortOrderList); + TokenizeStringL(aSortOrderString, sortOrderList); + + for ( TInt i = 0; i < sortOrderList.Count(); ++i ) + { + TUid uid = GetContactFieldType(sortOrderList[i]); + sortOrder.AppendL(uid); + } + + CleanupStack::PopAndDestroy(&sortOrderList); + return sortOrder; + } + +/** +* Retrieve the contact field uid information based on the contact field information specified in string format +* @param aContactFieldString - Contact field information in String format +* @return TUid - The contact field information in uid format +*/ + +TUid CContactUtilitiesCollection::GetContactFieldType(const TDesC& aContactFieldString) + { + + _LIT(KAddress, "Address"); + _LIT(KPostOffice, "PostOffice"); + _LIT(KExtendedAddress, "ExtendedAddress"); + _LIT(KLocality, "Locality"); + _LIT(KRegion, "Region"); + _LIT(KPostCode, "PostCode"); + _LIT(KCountry, "Country"); + _LIT(KCompanyName, "CompanyName"); + _LIT(KCompanyNamePronunciation, "CompanyNamePronunciation"); + _LIT(KPhoneNumber, "PhoneNumber"); + _LIT(KGivenName, "GivenName"); + _LIT(KFamilyName, "FamilyName"); + _LIT(KGivenNamePronunciation, "GivenNamePronunciation"); + _LIT(KFamilyNamePronunciation, "FamilyNamePronunciation"); + _LIT(KAdditionalName, "AdditionalName"); + _LIT(KSuffixName, "SuffixName"); + _LIT(KPrefixName, "PrefixName"); + _LIT(KHidden, "Hidden"); + _LIT(KEMail, "EMail"); + _LIT(KMsg, "Msg"); + _LIT(KSms, "Sms"); + _LIT(KFax, "Fax"); + _LIT(KNote, "Note"); + _LIT(KBirthday, "Birthday"); + _LIT(KUrl, "Url"); + _LIT(KPicture, "Picture"); + _LIT(KRingTone, "RingTone"); + _LIT(KDTMF, "DTMF"); + _LIT(KVoiceDialField, "VoiceDialField"); + _LIT(KJobTitle, "JobTitle"); + _LIT(KICCSlot, "ICCSlot"); + _LIT(KICCPhonebook, "ICCPhonebook"); + _LIT(KICCGroup, "ICCGroup"); + _LIT(KIMAddress, "IMAddress"); + _LIT(KSecondName, "SecondName"); + _LIT(KSIPID, "SIPID"); + _LIT(KAssistant, "Assistant"); + _LIT(KAnniversary, "Anniversary"); + _LIT(KSpouse, "Spouse"); + _LIT(KChildren, "Children"); + _LIT(KClass, "Class"); + _LIT(KDepartmentName, "DepartmentName"); + + TUid uid; + + if ( aContactFieldString.Compare(KAddress) == 0) + { + uid = KUidContactFieldAddress; + } + else if ( aContactFieldString.Compare(KPostOffice) == 0) + { + uid = KUidContactFieldPostOffice; + } + else if ( aContactFieldString.Compare(KExtendedAddress) == 0) + { + uid = KUidContactFieldExtendedAddress; + } + else if ( aContactFieldString.Compare(KLocality) == 0) + { + uid = KUidContactFieldLocality; + } + else if ( aContactFieldString.Compare(KRegion) == 0) + { + uid = KUidContactFieldRegion; + } + else if ( aContactFieldString.Compare(KPostCode) == 0) + { + uid = KUidContactFieldPostcode; + } + else if ( aContactFieldString.Compare(KCountry) == 0) + { + uid = KUidContactFieldCountry; + } + else if ( aContactFieldString.Compare(KCompanyName) == 0) + { + uid = KUidContactFieldCompanyName; + } + else if ( aContactFieldString.Compare(KCompanyNamePronunciation) == 0) + { + uid = KUidContactFieldCompanyNamePronunciation; + } + else if ( aContactFieldString.Compare(KPhoneNumber) == 0) + { + uid = KUidContactFieldPhoneNumber; + } + else if ( aContactFieldString.Compare(KGivenName) == 0) + { + uid = KUidContactFieldGivenName; + } + else if ( aContactFieldString.Compare(KFamilyName) == 0) + { + uid = KUidContactFieldFamilyName; + } + else if ( aContactFieldString.Compare(KGivenNamePronunciation) == 0) + { + uid = KUidContactFieldGivenNamePronunciation; + } + else if ( aContactFieldString.Compare(KFamilyNamePronunciation) == 0) + { + uid = KUidContactFieldFamilyNamePronunciation; + } + else if ( aContactFieldString.Compare(KAdditionalName) == 0) + { + uid = KUidContactFieldAdditionalName; + } + else if ( aContactFieldString.Compare(KSuffixName) == 0) + { + uid = KUidContactFieldSuffixName; + } + else if ( aContactFieldString.Compare(KPrefixName) == 0) + { + uid = KUidContactFieldPrefixName; + } + else if ( aContactFieldString.Compare(KHidden) == 0) + { + uid = KUidContactFieldHidden; + } + else if ( aContactFieldString.Compare(KEMail) == 0) + { + uid = KUidContactFieldEMail; + } + else if ( aContactFieldString.Compare(KMsg) == 0) + { + uid = KUidContactFieldMsg; + } + else if ( aContactFieldString.Compare(KSms) == 0) + { + uid = KUidContactFieldSms; + } + else if ( aContactFieldString.Compare(KFax) == 0) + { + uid = KUidContactFieldFax; + } + else if ( aContactFieldString.Compare(KNote) == 0) + { + uid = KUidContactFieldNote; + } + else if ( aContactFieldString.Compare(KBirthday) == 0) + { + uid = KUidContactFieldBirthday; + } + else if ( aContactFieldString.Compare(KUrl) == 0) + { + uid = KUidContactFieldUrl; + } + else if ( aContactFieldString.Compare(KPicture) == 0) + { + uid = KUidContactFieldPicture; + } + else if ( aContactFieldString.Compare(KRingTone) == 0) + { + uid = KUidContactFieldRingTone; + } + else if ( aContactFieldString.Compare(KDTMF) == 0) + { + uid = KUidContactFieldDTMF; + } + else if ( aContactFieldString.Compare(KVoiceDialField) == 0) + { + uid = KUidContactsVoiceDialField; + } + else if ( aContactFieldString.Compare(KJobTitle) == 0) + { + uid = KUidContactFieldJobTitle; + } + else if ( aContactFieldString.Compare(KICCSlot) == 0) + { + uid = KUidContactFieldICCSlot; + } + else if ( aContactFieldString.Compare(KICCPhonebook) == 0) + { + uid = KUidContactFieldICCPhonebook; + } + else if ( aContactFieldString.Compare(KICCGroup) == 0) + { + uid = KUidContactFieldICCGroup; + } + else if ( aContactFieldString.Compare(KIMAddress) == 0) + { + uid = KUidContactFieldIMAddress; + } + else if ( aContactFieldString.Compare(KSecondName) == 0) + { + uid = KUidContactFieldSecondName; + } + else if ( aContactFieldString.Compare(KSIPID) == 0) + { + uid = KUidContactFieldSIPID; + } + else if ( aContactFieldString.Compare(KAssistant) == 0) + { + uid = KUidContactFieldAssistant; + } + else if ( aContactFieldString.Compare(KAnniversary) == 0) + { + uid = KUidContactFieldAnniversary; + } + else if ( aContactFieldString.Compare(KSpouse) == 0) + { + uid = KUidContactFieldSpouse; + } + else if ( aContactFieldString.Compare(KChildren) == 0) + { + uid = KUidContactFieldChildren; + } + else if ( aContactFieldString.Compare(KClass) == 0) + { + uid = KUidContactFieldClass; + } + else if ( aContactFieldString.Compare(KDepartmentName) == 0) + { + uid = KUidContactFieldDepartmentName; + } + else + { + uid = KUidContactFieldNone; + } + + return uid; + } + +/* +* Get the view preferences from the ini and convert it of type TContactViewPreferences +* @param aViewPreferences viewPreferences passed from the ini file +* @return TContactViewPreferences +*/ +TContactViewPreferences CContactUtilitiesCollection::ConvertStringToContactViewPreferencesL(const TDesC& aViewPreferences) + { + _LIT(KContactsOnly, "contactsonly"); + _LIT(KGroupsOnly, "groupsonly"); + _LIT(KContactsAndGroups, "contactsandgroups"); + _LIT(KIgnoreUnsorted, "ignoreunsorted"); + _LIT(KUnsortedAtbeginning, "EUnsortedAtBeginning"); + _LIT(KUnsortedAtEnd, "EUnsortedAtEnd"); + _LIT(KSingleWhiteSpace, "ESingleWhiteSpaceIsEmptyField"); + _LIT(KICCEntries, "EICCEntriesOnly"); + _LIT(KICCEntriesAndContacts, "EICCEntriesAndContacts"); + + TUint viewPreferences = 0x00000000; + + RArray list; + CleanupClosePushL(list); + TokenizeStringL(aViewPreferences, list); + + for(TInt i = 0; i < list.Count(); ++i) + { + if( list[i] == KContactsOnly) + { + viewPreferences |= EContactsOnly; + } + else if(list[i] == KGroupsOnly) + { + viewPreferences |= EGroupsOnly; + } + else if(list[i] == KContactsAndGroups) + { + viewPreferences |= EContactAndGroups; + } + else if(list[i] == KIgnoreUnsorted) + { + viewPreferences |= EIgnoreUnSorted; + } + else if(list[i] == KUnsortedAtbeginning) + { + viewPreferences |= EUnSortedAtBeginning; + } + else if(list[i] == KUnsortedAtEnd) + { + viewPreferences |= EUnSortedAtEnd; + } + else if(list[i] == KSingleWhiteSpace) + { + viewPreferences |= ESingleWhiteSpaceIsEmptyField; + } + else if(list[i] == KICCEntries) + { + viewPreferences |= EICCEntriesOnly; + } + else if(list[i] == KICCEntriesAndContacts) + { + viewPreferences |= EICCEntriesAndContacts; + } + } + CleanupStack::PopAndDestroy(&list); + return (TContactViewPreferences)viewPreferences; + } + +/* +* Converts the string of type TSearchType which is used for view construction +* @param aSearchType The search type +* @return CContactViewBase::TSearchType +*/ +CContactViewBase::TSearchType CContactUtilitiesCollection::GetSearchType(const TDesC& aSearchType) + { + _LIT(KPrefixSearch, "EPrefixSearch"); + + CContactViewBase::TSearchType searchType = CContactViewBase::EFullSearch; + + if(aSearchType.Compare(KPrefixSearch) == 0 ) + { + searchType = CContactViewBase::EPrefixSearch; + } + + return searchType; + } + +/* +* Converts the string of type TGroupType which is used for view construction +* @param aGroupType The group type +* @return ContactViewBase::TGroupType +*/ +CContactGroupView::TGroupType CContactUtilitiesCollection::GetGroupType(const TDesC& aGroupType) + { + _LIT(KShowContactsInGroup, "EShowContactsInGroup"); + _LIT(KShowContactsNotInGroup, "EShowContactsNotInGroup"); + + CContactGroupView::TGroupType groupType = CContactGroupView::EShowContactsNotInAnyGroup; + + if ( aGroupType.Compare(KShowContactsInGroup) == 0 ) + { + groupType = CContactGroupView::EShowContactsInGroup; + } + else if ( aGroupType.Compare(KShowContactsNotInGroup) == 0 ) + { + groupType = CContactGroupView::EShowContactsNotInGroup; + } + + return groupType; + } + +/* +* converts the string of type TContactViewFilter which is used for construction of the views +* @param aFilter The filter to use +* @return CContactDataBase::TContactViewFilter +*/ +CContactDatabase::TContactViewFilter CContactUtilitiesCollection::GetContactViewFilterL(const TDesC& aFilter) + { + _LIT(KUnFiltered, "UnFiltered"); + _LIT(KMailable, "Mailable"); + _LIT(KSmsable, "Smsable"); + _LIT(KLandLine, "LandLine"); + _LIT(KFaxable, "Faxable"); + _LIT(KPhonable, "Phonable"); + _LIT(KWork, "Work"); + _LIT(KHome, "Home"); + _LIT(KRingTone, "RingTone"); + _LIT(KVoiceDial, "VoiceDial"); + _LIT(KIMAddress, "IMAddress"); + _LIT(KWirelessVillage, "WirelessVillage"); + _LIT(KCustomFilter1, "CustomFilter1"); + _LIT(KCustomFilter2, "CustomFilter2"); + _LIT(KCustomFilter3, "CustomFilter3"); + _LIT(KCustomFilter4, "CustomFilter4"); + + TUint viewFilter = 0x0; + + RArray list; + CleanupClosePushL(list); + TokenizeStringL(aFilter, list); + + for(TInt i = 0; i < list.Count(); ++i) + { + if( list[i] == KUnFiltered) + { + viewFilter |= CContactDatabase::EUnfiltered; + } + else if(list[i] == KMailable) + { + viewFilter |= CContactDatabase::EMailable; + } + else if(list[i] == KSmsable) + { + viewFilter |= CContactDatabase::ESmsable; + } + else if(list[i] == KLandLine) + { + viewFilter |= CContactDatabase::ELandLine; + } + else if(list[i] == KFaxable) + { + viewFilter |= CContactDatabase::EFaxable; + } + else if(list[i] == KPhonable) + { + viewFilter |= CContactDatabase::EPhonable; + } + else if(list[i] == KWork) + { + viewFilter |= CContactDatabase::EWork; + } + else if(list[i] == KHome) + { + viewFilter |= CContactDatabase::EHome; + } + else if(list[i] == KRingTone) + { + viewFilter |= CContactDatabase::ERingTone; + } + else if(list[i] == KVoiceDial) + { + viewFilter |= CContactDatabase::EVoiceDial; + } + else if(list[i] == KIMAddress) + { + viewFilter |= CContactDatabase::EIMAddress; + } + else if(list[i] == KWirelessVillage) + { + viewFilter |= CContactDatabase::EWirelessVillage; + } + else if(list[i] == KCustomFilter1) + { + viewFilter |= CContactDatabase::ECustomFilter1; + } + else if(list[i] == KCustomFilter2) + { + viewFilter |= CContactDatabase::ECustomFilter2; + } + else if(list[i] == KCustomFilter3) + { + viewFilter |= CContactDatabase::ECustomFilter3; + } + else if(list[i] == KCustomFilter4) + { + viewFilter |= CContactDatabase::ECustomFilter4; + } + } + + CleanupStack::PopAndDestroy(); //list + return (CContactDatabase::TContactViewFilter)viewFilter; + } + +/* +* Construct different types of views like local view, remote view, named remote view, find view, filtered view, +* group view, concatenated view and sub view based on the list of views specified in the ini file and append the views +* to their corresponding view array +* @param aSections ini sections +*/ +void CContactUtilitiesCollection::ConstructViewsL(RArray aSections) + { + // Iterating through the sections listed in the field listOfViews. + for ( TInt i = 0; i < aSections.Count(); ++i ) + { + TPtrC iniSection = aSections[i]; + TPtrC viewType; + BaseTestStepReference().GetStringFromConfig(iniSection, KViewType, viewType); + TPtrC allocTest; + BaseTestStepReference().GetStringFromConfig(iniSection, KAllocTest, allocTest); + + + if ( allocTest != KNullDesC() ) + { + OOMTestForViewsL(iniSection, viewType, allocTest); + } + else + { + if ( viewType.Compare(KLocalView) == 0 ) + { + // Construct Local view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructLocalViewL(iniSection); + } + if ( viewType.Compare(KRemoteView) == 0 ) + { + // Construct remote view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructRemoteViewL(iniSection); + } + if ( viewType.Compare(KNamedRemoteView) == 0 ) + { + // Construct named remote view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructNamedRemoteViewL(iniSection); + } + if ( viewType.Compare(KGroupView) == 0 ) + { + // Construct group view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructGroupViewL(iniSection); + } + if ( viewType.Compare(KFindView) == 0 ) + { + // Construct find view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructFindViewL(iniSection); + } + if ( viewType.Compare(KFilteredView) == 0 ) + { + // Construct filtered view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructFilteredViewL(iniSection); + } + if ( viewType.Compare(KConcatenatedView) == 0 ) + { + // Construct concatenated view based on the data defined in the ini section i.e aSections[i] + ConstructConcatenatedViewL(iniSection); + } + if ( viewType.Compare(KSubView) == 0 ) + { + // Construct sub view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructSubViewL(iniSection); + } + } + } + } + +/** +* Parses a comma separated string and constructs a list out of the values +* @param aString input string +* @param aList Array of seperated strings +* @param aSeparator , +*/ +void CContactUtilitiesCollection::TokenizeStringL(const TDesC& aString, RArray& aList, TChar aSeparator) + { + TLex lexer(aString); + + while(!lexer.Eos()) + { + lexer.SkipSpaceAndMark(); + + while(!lexer.Eos() && lexer.Get() != aSeparator) + { + } + + if(!lexer.Eos()) + { + lexer.UnGet(); // Do not include trailing ',' + } + aList.AppendL(lexer.MarkedToken()); + lexer.Inc(); + } + } + +/* +* OOM testing of views +* @param aSection ini section +* @param aViewType view type +* @param aAllocTest OOM test +*/ +void CContactUtilitiesCollection::CreateViewUnderOOMConditionL(const TDesC& aSection, const TDesC& aViewType, const TDesC& aAllocTest) + { + if ( aViewType.Compare(KGroupView) == 0 && aAllocTest.Compare(KGroupView) == 0 ) + { + // Construct group view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructGroupViewL(aSection); + } + else if ( aViewType.Compare(KFindView) == 0 && aAllocTest.Compare(KFindView) == 0 ) + { + // Construct find view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructFindViewL(aSection); + } + else if ( aViewType.Compare(KFilteredView) == 0 && aAllocTest.Compare(KFilteredView) == 0 ) + { + // Construct filtered view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructFilteredViewL(aSection); + } + else if ( aViewType.Compare(KSubView) == 0 && aAllocTest.Compare(KSubView) == 0 ) + { + // Construct sub view based on the data defined in the ini section i.e aSections[i] + GetDataAndConstructSubViewL(aSection); + } + } + +/* +* Construct the views in the OOM loop +* @param aSortOrder specifies the fields to use to sort the items in the view +* @param aViewPreferences specifies the type of the contact item to be included in the view +* @param aSortPlugin specifies a plug-in that will be used to compare view contacts when the view is sorted +*/ +void CContactUtilitiesCollection::OOMTestForViewsL(const TDesC& aSection, const TDesC& aViewType, const TDesC& aAllocTest) + { + TInt tryCount = 1; + for ( ;; ) + { + __UHEAP_SETFAIL(RHeap::EFailNext, tryCount); + + TRAPD(err, CreateViewUnderOOMConditionL(aSection, aViewType, aAllocTest)); + + if ( err == KErrNone ) + { + __UHEAP_RESET; + BaseTestStepReference().INFO_PRINTF1(_L("Memory allocation testing for View is done")); + break; + } + if ( err != KErrNoMemory ) + BaseTestStepReference().SetTestStepResult(EFail); + __UHEAP_SETFAIL(RHeap::ENone, 0); + tryCount++; + } + BaseTestStepReference().INFO_PRINTF2(_L("TRYCOUNT %d"), tryCount); + } + + +// CContactViewCollection + +CContactViewCollection* CContactViewCollection::NewL() + { + CContactViewCollection* self = new(ELeave) CContactViewCollection(); + return self; + } + +CContactViewCollection::CContactViewCollection() + { + } + +CContactViewCollection::~CContactViewCollection() + { + CloseLocalViewAndEventQueue(); + CloseRemoteViewAndEventQueue(); + CloseNamedRemoteViewAndEventQueue(); + CloseFindViewAndEventQueue(); + CloseFilteredViewAndEventQueue(); + CloseGroupViewAndEventQueue(); + CloseConcatenatedViewAndEventQueue(); + CloseSubViewAndEventQueue(); + iArrayOfViewBase.Close(); + iArrayViewEvents.Close(); + } + +/* +* Close the localvieweventqueue and localviewarray +*/ +void CContactViewCollection::CloseLocalViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfLocalViews.Count(); ++i ) + { + if (iArrayOfLocalViews.Count() > 0 && iArrayOfLocalViewEvents.Count() > 0) + { + iArrayOfLocalViews[i]->Close(*iArrayOfLocalViewEvents[i]); + delete iArrayOfLocalViewEvents[i]; + } + } + iArrayOfLocalViews.Close(); + } + +/* +* Close the RemoteView And its EventQueue +*/ +void CContactViewCollection::CloseRemoteViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfRemoteViews.Count(); ++i ) + { + if (iArrayOfRemoteViews.Count() > 0 && iArrayOfRemoteViewEvents.Count() > 0) + iArrayOfRemoteViews[i]->Close(*iArrayOfRemoteViewEvents[i]); + delete iArrayOfRemoteViewEvents[i]; + } + iArrayOfRemoteViews.Close(); + } + +/* +* Close the NamedRemoteView And its EventQueue +*/ +void CContactViewCollection::CloseNamedRemoteViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfNamedRemoteViews.Count(); ++i ) + { + if (iArrayOfNamedRemoteViews.Count() > 0 && iArrayOfNamedRemoteViewEvents.Count() > 0) + iArrayOfNamedRemoteViews[i]->Close(*iArrayOfNamedRemoteViewEvents[i]); + delete iArrayOfNamedRemoteViewEvents[i]; + } + iArrayOfNamedRemoteViews.Close(); + } + +/* +* Close the FindView And its EventQueue +*/ +void CContactViewCollection::CloseFindViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfFindViews.Count(); ++i ) + { + if (iArrayOfFindViews.Count() > 0 && iArrayOfFindViewEvents.Count() > 0) + iArrayOfFindViews[i]->Close(*iArrayOfFindViewEvents[i]); + delete iArrayOfFindViewEvents[i]; + } + iArrayOfFindViews.Close(); + } + +/* +* Close the FilteredView And its EventQueue +*/ +void CContactViewCollection::CloseFilteredViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfFilteredViews.Count(); ++i ) + { + if (iArrayOfFilteredViews.Count() > 0 && iArrayOfFilteredViewEvents.Count() > 0) + iArrayOfFilteredViews[i]->Close(*iArrayOfFilteredViewEvents[i]); + delete iArrayOfFilteredViewEvents[i]; + } + iArrayOfFilteredViews.Close(); + } + +/* +* Close the GroupView And its EventQueue +*/ +void CContactViewCollection::CloseGroupViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfGroupViews.Count(); ++i ) + { + if (iArrayOfGroupViews[i]) + iArrayOfGroupViews[i]->Close(*iArrayOfGroupViewEvents[i]); + delete iArrayOfGroupViewEvents[i]; + } + iArrayOfGroupViews.Close(); + } + +/* +* Close the ConcatenatedView And its EventQueue +*/ +void CContactViewCollection::CloseConcatenatedViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfConcatenatedViews.Count(); ++i ) + { + if (iArrayOfConcatenatedViews.Count() > 0 && iArrayOfConcatenatedViewEvents.Count() > 0) + iArrayOfConcatenatedViews[i]->Close(*iArrayOfConcatenatedViewEvents[i]); + delete iArrayOfConcatenatedViewEvents[i]; + } + iArrayOfConcatenatedViews.Close(); + } + +/* +* Close the SubView And its EventQueue +*/ +void CContactViewCollection::CloseSubViewAndEventQueue() + { + for ( TInt i = 0; i < iArrayOfSubViews.Count(); ++i ) + { + if (iArrayOfSubViews.Count() > 0 && iArrayOfSubViewEvents.Count() > 0) + iArrayOfSubViews[i]->Close(*iArrayOfSubViewEvents[i]); + delete iArrayOfSubViewEvents[i]; + } + iArrayOfSubViews.Close(); + } +/* +* retrieve the local view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetLocalViewArray() + { + return iArrayOfLocalViews; + } + +/* +* retrieve the remote view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetRemoteViewArray() + { + return iArrayOfRemoteViews; + } + +/* +* retrieve the named remote view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetNamedRemoteViewArray() + { + return iArrayOfNamedRemoteViews; + } + +/* +* retrieve the find view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetFindViewArray() + { + return iArrayOfFindViews; + } + +/* +* retrieve the group view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetGroupViewArray() + { + return iArrayOfGroupViews; + } + +/* +* retrieve the filtered view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetFilteredViewArray() + { + return iArrayOfFilteredViews; + } + +/* +* retrieve the concatenated view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetConcatenatedViewArray() + { + return iArrayOfConcatenatedViews; + } + +/* +* retrieve the sub view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetSubViewArray() + { + return iArrayOfSubViews; + } + +/* +* retrieve the component view array +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetComponentViews() + { + return iArrayOfViewBase; + } + +/* +* retrieve the view events array +* @param aTypeOfView type of the view events array to be retrieved +* @return RPointerArray& +*/ +RPointerArray& CContactViewCollection::GetContactViewEventsQueueL(const TDesC& aTypeOfView) + { + if ( aTypeOfView.Compare(KLocalView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfLocalViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfLocalViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KRemoteView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfRemoteViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfRemoteViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KNamedRemoteView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfNamedRemoteViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfNamedRemoteViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KFindView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfFindViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfFindViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KFilteredView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfFilteredViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfFilteredViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KGroupView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfGroupViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfGroupViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KConcatenatedView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfConcatenatedViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfConcatenatedViewEvents[i]); + } + } + else if ( aTypeOfView.Compare(KSubView) == 0 ) + { + for ( TInt i = 0; i < iArrayOfSubViewEvents.Count(); ++i ) + { + iArrayViewEvents.AppendL(iArrayOfSubViewEvents[i]); + } + } + return iArrayViewEvents; + } + +/* +* Get the desired local view located at the specified index in the array iArrayOfLocalViews +* @param aIndexOfView index of the view +* @return CContactLocalView +*/ +CContactLocalView* CContactViewCollection::GetDesiredLocalView(TInt aIndexOfView) + { + RPointerArray& localViewArray = GetLocalViewArray(); + CContactLocalView* localView = NULL; + for ( TInt i = 0; i < localViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + localView = localViewArray[i]; + } + } + return localView; + } + +/* +* Get the desired remote view located at the specified index in the array iArrayOfRemoteViews +* @param aIndexOfView index of the view +* @return CContactRemoteView +*/ +CContactRemoteView* CContactViewCollection::GetDesiredRemoteView(TInt aIndexOfView) + { + RPointerArray& remoteViewArray = GetRemoteViewArray(); + CContactRemoteView* remoteView = NULL; + for ( TInt i = 0; i < remoteViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + remoteView = remoteViewArray[i]; + } + } + return remoteView; + } + +/* +* Get the desired named remote view located at the specified index in the array iArrayOfNamedRemoteViews +* @param aIndexOfView index of the view +* @return CContactNamedRemoteView +*/ +CContactNamedRemoteView* CContactViewCollection::GetDesiredNamedRemoteView(TInt aIndexOfView) + { + RPointerArray& namedRemoteViewArray = GetNamedRemoteViewArray(); + CContactNamedRemoteView* namedRemoteView = NULL; + for ( TInt i = 0; i < namedRemoteViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + namedRemoteView = namedRemoteViewArray[i]; + } + } + return namedRemoteView; + } + +/* +* Get the desired find view located at the specified index in the array iArrayOfFindViews +* @param aIndexOfView index of the view +* @return CContactFindView +*/ +CContactFindView* CContactViewCollection::GetDesiredFindView(TInt aIndexOfView) + { + RPointerArray& findViewArray = GetFindViewArray(); + CContactFindView* findView = NULL; + for ( TInt i = 0; i < findViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + findView = findViewArray[i]; + } + } + return findView; + } + +/* +* Get the desired filtered view located at the specified index in the array iArrayOfFilteredViews +* @param aIndexOfView index of the view +* @return CContactFilteredView +*/ +CContactFilteredView* CContactViewCollection::GetDesiredFilteredView(TInt aIndexOfView) + { + RPointerArray& filteredViewArray = GetFilteredViewArray(); + CContactFilteredView* filteredView = NULL; + for ( TInt i = 0; i < filteredViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + filteredView = filteredViewArray[i]; + } + } + return filteredView; + } + +/* +* Get the desired group view located at the specified index in the array iArrayOfGroupViews +* @param aIndexOfView index of the view +* @return CContactGroupView +*/ +CContactGroupView* CContactViewCollection::GetDesiredGroupView(TInt aIndexOfView) + { + RPointerArray& groupViewArray = GetGroupViewArray(); + CContactGroupView* groupView = NULL; + for ( TInt i = 0; i < groupViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + groupView = groupViewArray[i]; + } + } + return groupView; + } + +/* +* Get the desired concatenated view located at the specified index in the array iArrayOfConcatenatedViews +* @param aIndexOfView index of the view +* @return CContactConcatenatedView +*/ +CContactConcatenatedView* CContactViewCollection::GetDesiredConcatenatedView(TInt aIndexOfView) + { + RPointerArray& concatenatedViewArray = GetConcatenatedViewArray(); + CContactConcatenatedView* concatenatedView = NULL; + for ( TInt i = 0; i < concatenatedViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + concatenatedView = concatenatedViewArray[i]; + } + } + return concatenatedView; + } + +/* +* Get the desired sub view located at the specified index in the array iArrayOfSubViews +* @param aIndexOfView index of the view +* @return CContactSubView +*/ +CContactSubView* CContactViewCollection::GetDesiredSubView(TInt aIndexOfView) + { + RPointerArray& subViewArray = GetSubViewArray(); + CContactSubView* subView = NULL; + for ( TInt i = 0; i < subViewArray.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + subView = subViewArray[i]; + } + } + return subView; + } + +/* +* Get the desired sub view located at the specified index in the array iArrayOfSubViews +* @param indexOfView index of the view +* @param aTypeOfView type of the view +* @return CContactViewEventQueue* +*/ +CContactViewEventQueue* CContactViewCollection::GetDesiredViewEventL(TInt aIndexOfView, const TDesC& aTypeOfView) + { + RPointerArray& viewEventsQueue = GetContactViewEventsQueueL(aTypeOfView); + CContactViewEventQueue* viewEvent = NULL; + for ( TInt i = 0; i < viewEventsQueue.Count(); ++i ) + { + if ( i == (aIndexOfView - 1) ) + { + viewEvent = viewEventsQueue[i]; + } + } + return viewEvent; + } + + +// CContactViewTest + +CContactViewApiTest::CContactViewApiTest(CTestStep* aTestStep) +: iTestStep(aTestStep) + { + } + +/** + * Constructor + */ +CContactViewApiTest* CContactViewApiTest::NewL(CTestStep* aTestStep) + { + CContactViewApiTest* self = new(ELeave) CContactViewApiTest(aTestStep); + return self; + } + +/** + * Destructor + */ +CContactViewApiTest::~CContactViewApiTest() + { + iFsSession.Close(); + } + + +CTestStep& CContactViewApiTest::TestStepReference() + { + return *iTestStep; + } + +/* +* Get the data required to test the AtL() API +* @param aSection ini section +* @return index +*/ +TInt CContactViewApiTest::GetAtLApiDataFromIni(const TDesC& aSection) + { + TInt index = -1; + TestStepReference().GetIntFromConfig(aSection, KAtLIndex, index); + return index; + } + +/* +* Pass the index of the contact item and get the contact item id +* @param aIndex index of the contact item id +* @param aView desired view +* @param aErrorCondition diskfull or not ready +* @return TContactItemId +*/ +TContactItemId CContactViewApiTest::AtL(TInt aIndex, CContactViewBase* aView, const TDesC& aErrorCondition) + { + TContactItemId contactItemId = 0; + // Accessing the view when it is in disk full condition + if ( aErrorCondition != KNullDesC() ) + { + #ifdef __DEBUG + SetFsErrorConditionL(aErrorCondition, KFsAccessCount); + #endif + TRAPD(err, contactItemId = aView->AtL(aIndex) ); + TPtrC errorCondition; + errorCondition.Set(_L("ErrorNone")); + #ifdef __DEBUG + SetFsErrorConditionL(errorCondition); + #endif + ValidateErrorCondition(err, aErrorCondition); + } + else + { + TRAPD(err, contactItemId = aView->AtL(aIndex) ); + if ( err != KErrNone ) + { + contactItemId = -1; + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + } + return contactItemId; + } + +/* +* Change the sortorder of the view +* @return index +*/ +void CContactViewApiTest::TestChangeSortOrderL(const TDesC& aSection, CContactUtilitiesCollection* aContactUtility) + { + CContactNamedRemoteView* namedRemoteview = NULL; + TInt index = -1; + TestStepReference().GetIntFromConfig(aSection, KIndexOfViews, index); + CContactViewCollection& viewCollection = aContactUtility->ViewCollectionReference(); + namedRemoteview = viewCollection.GetDesiredNamedRemoteView(index); + TPtrC viewSortOrder; + TestStepReference().GetStringFromConfig(aSection, KViewSortOrder, viewSortOrder); + RContactViewSortOrder sortOrder = aContactUtility->ConvertStringToSortOrderL(viewSortOrder); + namedRemoteview->ChangeSortOrderL(sortOrder); + User::After(10 * 1000000); + } + + + +/* +* Get the data required to test the ContactAtL() API +* @param aSection ini section +* @return index +*/ +TInt CContactViewApiTest::GetContactAtLApiDataFromIni(const TDesC& aSection) + { + TInt index = -1; + TestStepReference().GetIntFromConfig(aSection, KAtLIndex, index); + return index; + } + +/* +* Pass the index and get the contact item +* @param aIndex index of the contact item in the view +* @param aView desired view +* @return CViewContact +*/ +CViewContact* CContactViewApiTest::ContactAtL(TInt aIndex, CContactViewBase* aView) + { + CViewContact* viewContact = NULL; + TRAPD(err, viewContact = CViewContact::NewL(aView->ContactAtL(aIndex))); + if(err != KErrNone) + { + viewContact = NULL; + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + return viewContact; + } + +/* +* Get the data required for the FindL() API +* @param aSection ini section +* @return TInt contactItemId +*/ +TInt CContactViewApiTest::GetFindLApiDataFromIni(const TPtrC& aSection) + { + TInt contactItemId = -1; + TestStepReference().GetIntFromConfig(aSection, KContactItemId, contactItemId); + return contactItemId; + } + +/* +* Pass the contact item id and find the index of the contact item id +* @param aSection ini section +* @param aView desired view +* @param aErrorCondition diskfull or not ready +* @return index of the contact item id +*/ +TInt CContactViewApiTest::FindL(TContactItemId aId, CContactViewBase* aView, const TDesC& aErrorCondition) + { + TInt index(-1); + // Accessing the view when it is in disk full condition + if ( aErrorCondition != KNullDesC() ) + { + #ifdef __DEBUG + SetFsErrorConditionL(aErrorCondition, KFsAccessCount); + #endif + TRAPD( err, index = aView->FindL(aId)); + TPtrC errorCondition; + errorCondition.Set(_L("ErrorNone")); + #ifdef __DEBUG + SetFsErrorConditionL(errorCondition); + #endif + ValidateErrorCondition(err, aErrorCondition); + } + else + { + TRAPD( err, index = aView->FindL(aId)); + if ( err != KErrNone ) + { + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + } + return index; + } + +/* +* Get the fields required for testing AllFieldsLC() from the ini file +* @param aSection ini section +* @param aView desired view +* @return HBufC* contact item fields +*/ +HBufC* CContactViewApiTest::GetAllFieldsLDataFromIniL(const TDesC& aSection, CContactViewBase* aView) + { + TInt index = -1; + TPtrC fieldSeparator; + TestStepReference().GetIntFromConfig(aSection, KIndex, index); + TestStepReference().GetStringFromConfig(aSection, KFieldSeparator, fieldSeparator); + + return (GetAllFieldsL(index, fieldSeparator, aView)); + } + +/* +* Get all the fields of the contact item located at the specified index +* @param aIndex retrieved index +* @param aSeparator separator to separate the fields +* @param aView desired view +* @return HBufC* contact item fields +*/ +HBufC* CContactViewApiTest::GetAllFieldsL(TInt aIndex, const TDesC &aSeparator, CContactViewBase* aView) + { + HBufC* contactFields = NULL; + contactFields = aView->AllFieldsLC(aIndex, aSeparator); + if(contactFields!= NULL) + { + CleanupStack::Pop(contactFields); + } + return (contactFields); + } + +/* +* Get the sort order of the contact view +* @param aView desired view +* @param aErrorCondition diskfull or not ready +* @return RContactViewSortOrder sortOrder +*/ +RContactViewSortOrder CContactViewApiTest::GetSortOrderL(CContactViewBase* aView, const TDesC& aErrorCondition) + { + RContactViewSortOrder viewSortOrder; + // Accessing the view when it is in disk full condition + if ( aErrorCondition != KNullDesC() ) + { + #ifdef __DEBUG + SetFsErrorConditionL(aErrorCondition, KFsAccessCount); + #endif + TRAPD( err, viewSortOrder = aView->SortOrderL()); + TPtrC errorCondition; + errorCondition.Set(_L("ErrorNone")); + #ifdef __DEBUG + SetFsErrorConditionL(errorCondition); + #endif + ValidateErrorCondition(err, aErrorCondition); + } + else + { + TRAPD( err, viewSortOrder = aView->SortOrderL()); + if ( err != KErrNone ) + { + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + } + return viewSortOrder; + } + +/* +* Get the contact view preferences of the current view +* @param aView desired view +* @return TContactViewPreferences +*/ +TContactViewPreferences CContactViewApiTest::ContactViewPreferences(CContactViewBase* aView) + { + return (aView->ContactViewPreferences()); + } + +/* +* Refine the find view by passing new set of search words or append characters to the existing search words +* @param aSearchWords refined search words +* @param aView desired view +* @param aContactUtility utility pointer +*/ +void CContactViewApiTest::RefineFindViewL(const TDesC& aSearchWords, CContactFindView* aView, CContactUtilitiesCollection* aContactUtility) + { + RArray searchStrings; + CleanupClosePushL(searchStrings); + aContactUtility->TokenizeStringL(aSearchWords, searchStrings); + + // Search words to refine the find view + CPtrCArray* findWords = new(ELeave) CPtrCArray(3); + CleanupStack::PushL(findWords); + for ( TInt i = 0; i < searchStrings.Count(); ++i ) + { + findWords->AppendL(searchStrings[i]); + } + + // Refine the find view with the new find words + TRAPD( err, aView->RefineFindViewL(findWords) ); + if ( err != KErrNone ) + { + TestStepReference().ERR_PRINTF1(KErrInRefineFindView); + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + CleanupStack::PopAndDestroy(findWords); + CleanupStack::PopAndDestroy(&searchStrings); + } + +/* +* Get the contacts matching the specified criteria +* @param aSearchWords Criteria to search +* @param aView desired view +* @param aContactUtility utility pointer +* @return RPointerArray +*/ +RPointerArray CContactViewApiTest::GetContactsMatchingCriteriaL(const TDesC& aSearchWords, CContactViewBase* aView, + CContactUtilitiesCollection* aContactUtility, const TDesC& aErrorCondition) + { + RArray searchStrings; + CleanupClosePushL(searchStrings); + aContactUtility->TokenizeStringL(aSearchWords, searchStrings); + + // Append the search strings in the array which is required to pass in the API + CPtrCArray* findWords = new(ELeave) CPtrCArray(3); + CleanupStack::PushL(findWords); + for ( TInt i = 0; i < searchStrings.Count(); ++i ) + { + findWords->AppendL(searchStrings[i]); + } + + // get the contacts matching the findwords and return the matched contacts in the array + RPointerArray matchedContacts; + if ( aErrorCondition != KNullDesC() ) + { + #ifdef __DEBUG + SetFsErrorConditionL(aErrorCondition, KFsAccessCount); + #endif + TRAPD( err, aView->ContactsMatchingCriteriaL(*findWords, matchedContacts) ); + TPtrC errorCondition; + errorCondition.Set(_L("ErrorNone")); + #ifdef __DEBUG + SetFsErrorConditionL(errorCondition); + #endif + ValidateErrorCondition(err, aErrorCondition); + } + else + { + TRAPD( err, aView->ContactsMatchingCriteriaL(*findWords, matchedContacts) ); + if ( err != KErrNone ) + { + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + } + CleanupStack::PopAndDestroy(findWords); + CleanupStack::PopAndDestroy(&searchStrings); + return matchedContacts; + } + +/* +* Get the contacts where the search words matches the prefix of the contacts +* @param aSearchWords Criteria to search +* @param aView desired view +* @param aContactUtility utility pointer +* @return RPointerArray +*/ +RPointerArray CContactViewApiTest::GetContactsMatchingPrefixL(const TDesC& aSearchWords, CContactViewBase* aView, + CContactUtilitiesCollection* aContactUtility, const TDesC& aErrorCondition) + { + RArray searchStrings; + CleanupClosePushL(searchStrings); + aContactUtility->TokenizeStringL(aSearchWords, searchStrings); + // Append the search strings in the array which is required to pass in the ini file + CPtrCArray* findWords = new(ELeave) CPtrCArray(3); + CleanupStack::PushL(findWords); + for ( TInt i = 0; i < searchStrings.Count(); ++i ) + { + findWords->AppendL(searchStrings[i]); + } + // Get the contacts where the search words matches the prefix and return the matched contacts in the array + RPointerArray matchedContacts; + if ( aErrorCondition != KNullDesC() ) + { + #ifdef __DEBUG + SetFsErrorConditionL(aErrorCondition, KFsAccessCount); + #endif + TRAPD( err, aView->ContactsMatchingPrefixL(*findWords, matchedContacts) ); + TPtrC errorCondition; + errorCondition.Set(_L("ErrorNone")); + #ifdef __DEBUG + SetFsErrorConditionL(errorCondition); + #endif + ValidateErrorCondition(err, aErrorCondition); + } + else + { + TRAPD( err, aView->ContactsMatchingPrefixL(*findWords, matchedContacts) ); + if ( err != KErrNone ) + { + TestStepReference().SetTestStepError(err); + TestStepReference().SetTestStepResult(EFail); + } + } + CleanupStack::PopAndDestroy(findWords); + CleanupStack::PopAndDestroy(&searchStrings); + return matchedContacts; + } + + +/** Based on the error condition, call the respective validate function +* @param aErr actual error code -- KErrDiskFull/KErrNotReady +* @param aErrorCondition expected error --- KErrDiskFull/KErrNotReady +*/ +void CContactViewApiTest::ValidateErrorCondition(TInt aErr, const TDesC& aErrorCondition) + { + if ( aErrorCondition.Compare(KDiskFull) == 0 ) + { + ValidateResult(aErr, KErrDiskFull); + } + else + { + if ( aErrorCondition.Compare(KDiskNotReady) == 0 ) + { + ValidateResult(aErr, KErrNotReady); + } + else + { + ValidateResult(aErr, KErrNone); + } + } + } + +/** Validate and set the TestStep result to EFail, if required +* @param aActualResult - actual result +* @param aDesiredResult - desired result +*/ +void CContactViewApiTest::ValidateResult(TInt aActualResult, TInt aDesiredResult) + { + if(aActualResult != aDesiredResult) + { + + TestStepReference().ERR_PRINTF3(KError, aActualResult, aDesiredResult); + TestStepReference().SetTestStepResult(EFail); + } + } + +#ifdef _DEBUG +/** +* Set the error condition to the file system +* @param aErrorCondition KDiskFull or KDiskNotReady +* @param aCount count +*/ +void CContactViewApiTest::SetFsErrorConditionL(const TDesC& aErrorCondition, TInt aCount) + { + RFs& fs = GetFsSessionL(); + TInt res; + if ( aErrorCondition.Compare(KDiskFull) == 0 ) + { + res = fs.SetErrorCondition(KErrDiskFull, aCount); + + } + else if ( aErrorCondition.Compare(KDiskNotReady) == 0 ) + { + res = fs.SetErrorCondition(KErrNotReady, aCount); + } + else if ( aErrorCondition.Compare(KErrorNone) == 0 ) + { + res = fs.SetErrorCondition(0, aCount); + } + if(res != KErrNone) + { + TestStepReference().SetTestStepError(res); + TestStepReference().SetTestStepResult(EFail); + } + } +#endif + +/* +* Create a session with the file server +* @return RFs& file session +*/ +RFs& CContactViewApiTest::GetFsSessionL() + { + User::LeaveIfError(iFsSession.Connect()); + return iFsSession; + } + + +/** +* CContactViewValidation +*/ + +CContactViewValidation::CContactViewValidation(CTestStep* aTestStep) +: iTestStep(aTestStep) + { + } + +/* +* Destructor +*/ +CContactViewValidation::~CContactViewValidation() + { + } + +/* +* Returns the test step reference +* @return CTestStep& +*/ +CTestStep& CContactViewValidation::TestStepReference() + { + return *iTestStep; + } + +/* +* Validate the Contact item id returned by the AtL() API with the expected contact item id +* @param aContactItemId retrieved contact item id from the API +* @param aSection ini section +*/ +void CContactViewValidation::ValidateAtLApi(TContactItemId aContactItemId, const TDesC& aSection) + { + TInt desiredContactItemId = -1; + TestStepReference().GetIntFromConfig(aSection, KDesiredContactItemId, desiredContactItemId); + if ( desiredContactItemId != aContactItemId ) + { + TestStepReference().ERR_PRINTF3(KErrExpectedAndRetrivedContactItemId, desiredContactItemId, aContactItemId); + TestStepReference().SetTestStepResult(EFail); + } + } + +/* +* Validate the Contact item id returned by the AtL() API with the expected contact item id +* @param aViewContact retrieved contact item +* @param aSection ini section +*/ +void CContactViewValidation::ValidateContactAtLApi(CViewContact* aViewContact, const TDesC& aSection) + { + TInt desiredContactId = -1; + TestStepReference().GetIntFromConfig(aSection, KDesiredContactId, desiredContactId); + + if ( aViewContact->Id() != desiredContactId ) + { + TestStepReference().ERR_PRINTF1(KErrInContactType); + TestStepReference().SetTestStepResult(EFail); + } + } + +/* +* Validate count with the expectedCount +* @param aSection ini section +* @param aCount retrieved count from the API +*/ +void CContactViewValidation::ValidateCountL(const TDesC& aSection, TInt aCount) + { + TInt desiredCount = -1; + TestStepReference().GetIntFromConfig(aSection, KDesiredCount, desiredCount); + if ( aCount != desiredCount ) + { + TestStepReference().ERR_PRINTF3(KErrExpectedAndRetrievedCount, desiredCount, aCount); + TestStepReference().SetTestStepResult(EFail); + } + } + +/* +* Validate the index returned by FindL() API with the expected Index +* @param aSection ini section +* @param aIndex retrieved index +*/ +void CContactViewValidation::ValidateFindL(const TDesC& aSection, TInt aIndex) + { + TInt desiredIndex = -1; + TestStepReference().GetIntFromConfig(aSection, KDesiredIndex, desiredIndex); + if ( aIndex != desiredIndex ) + { + TestStepReference().ERR_PRINTF3(KErrExpectedAndRetrievedIndex, desiredIndex, aIndex); + TestStepReference().SetTestStepResult(EFail); + } + } + +/* +* Validate all the fields of the contact item and compare it the with the expected fields +* @param aSection ini section +* @param retrievedField fields retrieved by the API +* @param aView deisred view +*/ +void CContactViewValidation::ValidateAllFieldsL(const TDesC& aSection, RArray aRetrievedField, CContactViewBase* aView, + CContactViewApiTest* aViewApiTest) + { + TInt index = -1; + TestStepReference().GetIntFromConfig(aSection, KIndex, index); + // Get the contact item located at the specified index in the view + CViewContact* viewContact = aViewApiTest->ContactAtL(index, aView); + // Count the number of fields for the contact item + TInt count = viewContact->FieldCount(); + TPtrC field; + for ( TInt i = 0; i < count; ++i ) + { + //retrieve the fields one by one by specifying the position + field.Set(viewContact->Field(i)); + // Compare the fields retrived by AllFieldsLC() and ContactAtL() API's and log the result + if ( aRetrievedField[i] != field ) + { + TestStepReference().ERR_PRINTF3(KErrExpectedAndRetrievedFields, &field, &aRetrievedField[i]); + TestStepReference().SetTestStepResult(EFail); + } + } + } + +/* +* Validate the view preferences with the expected view preferences +* @param aSection ini section +* @param viewPreferences retrieved view preferences +*/ +void CContactViewValidation::ValidateViewPreferencesL(const TDesC& aSection, TContactViewPreferences& aViewPreferences, + CContactUtilitiesCollection* aContactUtility) + { + TPtrC viewPreferences1; + TestStepReference().GetStringFromConfig(aSection, KViewPreferences, viewPreferences1); + TContactViewPreferences expectedViewPreferences = aContactUtility->ConvertStringToContactViewPreferencesL(viewPreferences1); + if ( expectedViewPreferences != aViewPreferences) + { + TestStepReference().ERR_PRINTF3(KErrExpectedAndRetrievedViewPreferences, expectedViewPreferences, aViewPreferences); + TestStepReference().SetTestStepResult(EFail); + } + } + +/* +* Validate the uid's of the expected and retrieved sort order +* @param aUid retrieved Uid from the API +* @param aExpecteUid expectedUid passed from the ini file +*/ +void CContactViewValidation::ValidateSortOrderL(const TUid& aUid, const TUid& aExpectedUid) + { + if ( aUid != aExpectedUid ) + { + TestStepReference().ERR_PRINTF3(KErrExpectedAndRetrievedUid, aUid, aExpectedUid); + TestStepReference().SetTestStepResult(EFail); + } + } + +/* +* Imports contacts from a VCF file into specified database file +* @param aSection ini section +* @param aImportFileName file to be imported +* @param aDb reference to the pointed of CContactDatabase +*/ +void CContactUtilitiesCollection::ImportVcardContactsL(const TPtrC& aImportFileName, TBool aPbapBased) + { + // Get the version of the VCard parser to be used + TUid pluginUid; + pluginUid.iUid = KUidVCardConvDefaultImpl; // Supports version 2.1 and 3.0 + + + if( aPbapBased ) + { + pluginUid.iUid = KUidPBAPVCardConvImpl; // used only when the vCard has pbap specific properties + } + + // Connect to file system + RFs fsSession; + User::LeaveIfError(fsSession.Connect()); + CleanupClosePushL(fsSession); + RFileReadStream readStream; + CleanupClosePushL(readStream); + + // Open the the file from which the contact data has to be imported + User::LeaveIfError(readStream.Open(fsSession, aImportFileName, EFileRead)); + + CArrayPtr* item = NULL; + TBool success = EFalse; + CContactDatabase& cDb = DatabaseReference(); + FOREVER + { + TRAPD( err, item = cDb.ImportContactsL(pluginUid, readStream, success, CContactDatabase::EImportSingleContact) ); + if( success == EFalse ) // success will set to false, if there are issues during import operation + { // or all the contacts in the vcf file are imported + break; + } + if ( err != KErrNone ) + { + _LIT(KErrInImportContacts, "Error in importcontacts"); + BaseTestStepReference().ERR_PRINTF1(KErrInImportContacts); + } + + if( item->Count() ) + { + item->ResetAndDestroy(); + } + } + + CleanupStack::PopAndDestroy(); // readStream + CleanupStack::PopAndDestroy(); // fsSession + } + +/* +* Get the desired view observer +* @param aTypeOfView Type of view like local, Remote, NamedRemote etc. +* @param aViewIndex Index of the view +* @return CContactViewEventQueue returns a reference to the desired view observer +*/ +CContactViewEventQueue& CContactViewCollection::GetDesiredViewObserver(const TDesC& aTypeOfView, const TInt aViewIndex) + { + CContactViewEventQueue* viewEventQueue = NULL; + + if ( aTypeOfView.Compare(KLocalView) == 0 ) + { + viewEventQueue = iArrayOfLocalViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KRemoteView) == 0 ) + { + viewEventQueue = iArrayOfRemoteViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KNamedRemoteView) == 0 ) + { + viewEventQueue = iArrayOfNamedRemoteViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KFindView) == 0 ) + { + viewEventQueue = iArrayOfFindViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KFilteredView) == 0 ) + { + viewEventQueue = iArrayOfFilteredViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KGroupView) == 0 ) + { + viewEventQueue = iArrayOfGroupViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KConcatenatedView) == 0 ) + { + viewEventQueue = iArrayOfConcatenatedViewEvents[aViewIndex]; + } + else if ( aTypeOfView.Compare(KSubView) == 0 ) + { + viewEventQueue = iArrayOfSubViewEvents[aViewIndex]; + } + return *viewEventQueue; + } + +/* +* Get the desired view +* @param aTypeOfView Type of view like local, Remote, NamedRemote etc. +* @param aViewIndex Index of the view +* @return CContactViewBase return the pointer of desired view +*/ +CContactViewBase* CContactViewCollection::GetDesiredView(const TDesC& aTypeOfView, const TInt aViewIndex) + { + CContactViewBase* desiredView = NULL; + + if ( aTypeOfView.Compare(KLocalView) == 0 ) + { + desiredView = iArrayOfLocalViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KRemoteView) == 0 ) + { + desiredView = iArrayOfRemoteViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KNamedRemoteView) == 0 ) + { + desiredView = iArrayOfNamedRemoteViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KFindView) == 0 ) + { + desiredView = iArrayOfFindViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KFilteredView) == 0 ) + { + desiredView = iArrayOfFilteredViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KGroupView) == 0 ) + { + desiredView = iArrayOfGroupViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KConcatenatedView) == 0 ) + { + desiredView = iArrayOfConcatenatedViews[aViewIndex]; + } + else if ( aTypeOfView.Compare(KSubView) == 0 ) + { + desiredView = iArrayOfSubViews[aViewIndex]; + } + return desiredView; + } + +/* +* Construct the desired views based on data from the ini file +*/ +void CContactUtilitiesCollection::ConstructViewsL() + { + TPtrC listOfViews; + BaseTestStepReference().GetStringFromConfig(BaseTestStepReference().ConfigSection(), SharedConstants::KListOfViews, listOfViews); + RArray sections; + CleanupClosePushL(sections); + TokenizeStringL(listOfViews, sections); + ConstructViewsL(sections); + CleanupStack::PopAndDestroy(§ions); + } + +/* +* Wait for view to ready +* @param aViewEventQueue used to queued the events. +*/ +void CContactUtilitiesCollection::WaitForViewReady(CContactViewEventQueue*& aViewEventQueue) + { + TContactViewEvent event; + // wait for the event to get ready + TBool eventReady = aViewEventQueue->ListenForEvent(KEventWaitTime, event); + __ASSERT_ALWAYS(eventReady, User::Invariant()); + ASSERT(event.iEventType == TContactViewEvent::EReady); + } + +/* +* Retrieve the desired contact view observer from the view collection +* @param aTestStepReference - Reference to current test step, used to read data from the ini file +*/ +CContactViewEventQueue& CContactViewCollection::RetrieveDesiredViewObserverL( + CTestStep& aTestStepReference) + + { + TInt desiredViewIndex = 0; + _LIT(KDesiredViewIndex, "DesiredViewIndex"); + aTestStepReference.GetIntFromConfig(aTestStepReference.ConfigSection(), KDesiredViewIndex, desiredViewIndex); + + TPtrC desiredViewType; + _LIT(KDesiredViewType, "DesiredViewType"); + aTestStepReference.GetStringFromConfig(aTestStepReference.ConfigSection(), KDesiredViewType, desiredViewType); + + return(GetDesiredViewObserver(desiredViewType, desiredViewIndex)); + } + +/* +* Imports contacts into database +*/ +void CContactUtilitiesCollection::ImportContactsL() + { + // File from where contacts must be imported + TPtrC importFileName; + TBool filePresent; + filePresent = BaseTestStepReference().GetStringFromConfig(BaseTestStepReference().ConfigSection(), SharedConstants::KFileToBeImported, importFileName); + + TBool pbapBased = EFalse; + BaseTestStepReference().GetBoolFromConfig(BaseTestStepReference().ConfigSection(), SharedConstants::KVCardVersionPBAP, pbapBased); + if(filePresent) + { + ImportVcardContactsL(importFileName, pbapBased); + } + } +