contacts_plat/predictivesearch_client_api/tsrc/PsClientTestSuite/src/PsClientTestSuiteBlocks.cpp
/*
* Copyright (c) 2002 - 2007 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: ?Description
*
*/
// SYSTEM INCLUDE FILES
#include <e32svr.h>
#include <StifParser.h>
#include <Stiftestinterface.h>
#include "PsClientTestSuite.h"
#include <CPsQueryItem.h>
#include <CPcsDefs.h>
#include <CPsQuery.h>
#include <CPsRequestHandler.h>
#include <CPsClientData.h>
#include <badesca.h>
// Defines
#define KOneSecDelay 1000000
_LIT(groupformat,"cntdb://c:contacts.gdb?id=");
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CPsClientTestSuite::Delete
// Delete here all resources allocated and opened from test methods.
// Called from destructor.
// -----------------------------------------------------------------------------
//
void CPsClientTestSuite::Delete()
{
}
// -----------------------------------------------------------------------------
// CPsClientTestSuite::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CPsClientTestSuite::RunMethodL( CStifItemParser& aItem )
{
TStifFunctionInfo const KFunctions[] = {
// First string is the function name used in TestScripter script file.
// Second is the actual implementation member function.
ENTRY( "WriteTitleToLog", CPsClientTestSuite::WriteTitleToLog ),
ENTRY( "CreateContactsInPhone", CPsClientTestSuite::CreateContactsL ),
ENTRY( "ADDGroups", CPsClientTestSuite::CreateGroupsInPhoneL ),
ENTRY( "DeleteAllContactsInPhonebook", CPsClientTestSuite::DeleteAllContactsInPhonebookL ),
ENTRY( "SearchOnInputString", CPsClientTestSuite::SearchOnInputStringL ),
ENTRY( "TC_ITU_SearchOnInputString", CPsClientTestSuite::SearchOnInputStringL ), // For easy handling of .cgf file
ENTRY( "TC_N97_SearchOnInputString", CPsClientTestSuite::SearchOnInputStringL ), // For easy handling of .cgf file
ENTRY( "TC_N00_SearchOnInputString", CPsClientTestSuite::SearchOnInputStringL ), // For easy handling of .cgf file
ENTRY( "SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ),
ENTRY( "TC_ITU_SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ), // For easy handling of .cgf file
ENTRY( "TC_N97_SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ), // For easy handling of .cgf file
ENTRY( "TC_N00_SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ), // For easy handling of .cgf file
ENTRY( "TestSearchingInCache", CPsClientTestSuite::SearchCacheL ),
ENTRY( "TC_ITU_TestSearchingInCache", CPsClientTestSuite::SearchCacheL ), // For easy handling of .cgf file
ENTRY( "TC_N97_TestSearchingInCache", CPsClientTestSuite::SearchCacheL ), // For easy handling of .cgf file
ENTRY( "TC_N00_TestSearchingInCache", CPsClientTestSuite::SearchCacheL ), // For easy handling of .cgf file
ENTRY( "CheckAdaptiveString", CPsClientTestSuite::CheckAdaptiveStringL ),
ENTRY( "CheckCachingStatus", CPsClientTestSuite::CheckCachingStatusL ),
ENTRY( "CheckVersion", CPsClientTestSuite::CheckVersion),
ENTRY( "CheckLanguageSupport", CPsClientTestSuite::TestIsLanguageSupportedL),
ENTRY( "GetAllContents", CPsClientTestSuite::GetAllContentsL),
ENTRY( "TestSortOrder", CPsClientTestSuite::TestSortOrderL),
ENTRY( "TestSortOrderErrCaseL", CPsClientTestSuite::TestSortOrderErrCaseL),
ENTRY( "TestSearchingWithInGroup", CPsClientTestSuite::SearchWithInGroupL),
ENTRY( "ConvertToVpbkLink", CPsClientTestSuite::ConvertToVpbkLinkL),
ENTRY( "RemoveObserver", CPsClientTestSuite::RemoveObserverL ),
ENTRY( "ShutDown", CPsClientTestSuite::ShutDownL ),
ENTRY( "AddMarkedContactsTest", CPsClientTestSuite::AddMarkedContactsTestL ),
ENTRY( "TestDataOrder", CPsClientTestSuite::TestDataOrderL ),
ENTRY( "TestDataOrderForErrL", CPsClientTestSuite::TestDataOrderForErrL ),
ENTRY( "CancelSearch", CPsClientTestSuite::CancelSearchL )
};
const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );
return RunInternalL( KFunctions, count, aItem );
}
// -----------------------------------------------------------------------------
// This writes a log line to ease search of the execution logs
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::WriteTitleToLog( )
{
iReturnStatus = KErrNone;
TName title;
TestModuleIf().GetTestCaseTitleL(title);
// Write the log
#ifdef _DEBUG
#ifdef __WINS__
RDebug::Print( _L("[PCS] ################################################################") );
RDebug::Print( _L("[PCS] ##### STIF: %S"), &title );
RDebug::Print( _L("[PCS] ################################################################") );
#endif // __WINS__
#endif // _DEBUG
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case creates contacts in the phonebook
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::CreateContactsL( CStifItemParser& aItem )
{
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Create the contacts
iInputParsedData->CreateContactsL();
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case creates groups in the phonebook
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::CreateGroupsInPhoneL( CStifItemParser& aItem )
{
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case creates a new CPsQueryItem object and checks
// if the creation is successfull.
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::SearchCacheL( CStifItemParser& aItem )
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Create the contacts
iInputParsedData->CreateContactsL();
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
// Create the search query
iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->SearchL(*iPsQuery);
CActiveScheduler::Start();
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case creates a new CPsQueryItem object and checks
// if search cancelling doesn't crash.
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::CancelSearchL( CStifItemParser& aItem )
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
// Create the search query
iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->SearchL(*iPsQuery);
//Cancel search
iPsClientHandler->CancelSearch();
//Wait for one second
RTimerWait(KOneSecDelay);
// return error code
return KErrNone;
}
void CPsClientTestSuite::HandlePsResultsUpdate(RPointerArray<CPsClientData>& searchResults,
RPointerArray<CPsPattern>& /*searchSeqs*/)
{
RArray<TInt> contactIdsArray;
TInt leaveErrorCode(KErrNone);
switch(iCurrentOperation)
{
case EDeleteSearchedResults:
// Deleted all the contacts contained in the search results
for(TInt i =0 ; i< searchResults.Count();i++)
{
contactIdsArray.Append(searchResults[i]->Id());
}
TRAP( iReturnStatus, iInputParsedData->DeleteContactsWithIdsL(contactIdsArray) );
break;
case EGetGroupId:
// Get the group Id. If there are more than one results,
// then there is an error
if(searchResults.Count() == 1)
{
iGroupToBeSearchedId = searchResults[0]->Id();
}
else if(searchResults.Count() > 1)
{
iReturnStatus = KErrArgument;
}
CActiveScheduler::Stop();
break;
case EConvertToVpbkLink:
// Get the contact link for the first element.
if(searchResults.Count() )
{
iReturnStatus = KErrNone;
TRAP ( leaveErrorCode,
TBool ret = iInputParsedData->TestVpbkLinkForIdL(*iPsClientHandler,*(searchResults[0]));
if (!ret)
iReturnStatus = KErrGeneral;
);
if ( leaveErrorCode )
{
iReturnStatus = leaveErrorCode;
}
}
else
{
iReturnStatus = KErrGeneral;
}
CActiveScheduler::Stop();
break;
case EMarkedContacts:
TRAP( leaveErrorCode,
for(TInt i =0; i < searchResults.Count(); i++)
{
CPsClientData* markContact = searchResults[i]->CloneL();
iMarkedContacts.Append(markContact);
}
);
if ( leaveErrorCode )
{
iReturnStatus = leaveErrorCode;
}
CActiveScheduler::Stop();
break;
case EDefaultCase:
// Search is complete. Compare the results with expected results
TRAP( leaveErrorCode, iReturnStatus = iInputParsedData->CompareResWithExpResL(searchResults));
if ( leaveErrorCode )
{
iReturnStatus = leaveErrorCode;
}
CActiveScheduler::Stop();
break;
default :
break;
} // End Switch
}
// -----------------------------------------------------------------------------
// Searches for a query in input string.
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::SearchOnInputStringL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem);
//Get the input string
HBufC* inputStr = iInputParsedData->InputSearchString().AllocL();
//To obtain the result;
CDesCArray* matchSet = new( ELeave ) CDesCArrayFlat(1);
RArray<TPsMatchLocation> matchLocation;
// Create the search query
iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->LookupL(*iPsQuery, *inputStr, *matchSet, matchLocation);
// Retrieve the expected result
RPointerArray<cacheData> expResultData;
iInputParsedData->ResultData(expResultData);
// If the expected search result has more than one element, then
// it is an error since we have only one input string to be searched.
if(expResultData.Count() > 1)
{
iReturnStatus = KErrArgument;
}
// Perform the comparison of matched sequences
TInt expResCount = 0;
if(expResultData.Count())
{
expResCount = expResultData[0]->data.Count();
}
else
{
expResCount = 0;
}
// compare the obtained result with desired result set
if( (matchSet->Count() == expResCount) && (KErrNone == iReturnStatus) )
{
TInt totalMatches = 0;
for(TInt i = 0; i < matchSet->Count(); i++)
{
for(TInt j = 0; j < expResultData[0]->data.Count(); j++)
{
HBufC* temp1 = ((*matchSet)[i]).AllocL();
HBufC* temp2 = (*(expResultData[0]->data[j])).AllocL();
temp1->Des().LowerCase();
temp2->Des().LowerCase();
if((*temp1).Compare(*temp2) == 0 )
{
totalMatches++;
expResultData[0]->data.Remove(j);
break;
}
}
}
// If the totalmatches == total number of results in match set,
// then testcase is successful
if(matchSet->Count() == totalMatches)
{
iReturnStatus = KErrNone;
}
else
{
iReturnStatus = KErrArgument;
}
}
else
{
iReturnStatus = KErrArgument;
}
//compare match Locations
const RArray<TPsMatchLocation>& expectedLocations = iInputParsedData->ExpectedLocations();
if ( expectedLocations.Count() != matchLocation.Count() )
{
iReturnStatus = KErrArgument; //matchLocations differs from expected result
}
for ( TInt i(0); i < expectedLocations.Count() && KErrNone == iReturnStatus; ++i )
{
if ( (expectedLocations[i].index != matchLocation[i].index) ||
(expectedLocations[i].length != matchLocation[i].length) )
{
iReturnStatus = KErrArgument; //matchLocations differs from expected result
}
}
matchLocation.Close();
matchLocation.Reset();
matchSet->Reset();
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Searches for a query in input string.
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::SearchLookupMatchStringL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem);
//Get the input string
HBufC* inputStr = iInputParsedData->InputSearchString().AllocL();
// Create the search query
iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());
TBuf<KPsQueryMaxLen> result;
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->LookupMatchL(*iPsQuery, *inputStr, result);
if ( iInputParsedData->ExpectedResultString() != result )
{
iReturnStatus = KErrArgument;
}
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Checks the Adaptive Grid string.
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::CheckAdaptiveStringL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem);
// If more than one cacheuris are configured, this is not
// supported by the test suite
HBufC* dataStore = HBufC::NewL(50);
if(iInputParsedData->CacheUrisCount() == 1)
{
dataStore->Des().Copy(iInputParsedData->CacheUris(0));
}
else
{
User::Leave(KErrArgument);
}
CDesCArrayFlat* dataStoreArr = NULL;
dataStoreArr = new (ELeave) CDesCArrayFlat( 1 );
CleanupStack::PushL( dataStoreArr );
dataStoreArr->AppendL( *dataStore );
// Search Text
//Get the input string
HBufC* searchText = iInputParsedData->InputSearchString().AllocL();
// Company Name
TBool companyName = iInputParsedData->InputBoolean();
TBuf<KPsAdaptiveGridStringMaxLen> result;
// Wait for one second
RTimerWait(KOneSecDelay);
TPtrC16 ptr = dataStoreArr->MdcaPoint(0);
// Get the Adaptive Grid
iPsClientHandler->GetAdaptiveGridCharactersL( *dataStoreArr,
searchText->Des(),
companyName,
result );
CleanupStack::PopAndDestroy( dataStoreArr );
delete dataStore;
if ( iInputParsedData->ExpectedResultString() != result )
{
iReturnStatus = KErrArgument;
}
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Stores the caching status of the psengine
// -----------------------------------------------------------------------------
void CPsClientTestSuite::CachingStatus(TCachingStatus& aStatus, TInt& /*aError*/)
{
// implement later
iCachingStatus = aStatus ;
}
// -----------------------------------------------------------------------------
// Handle the error from the ps engine
// -----------------------------------------------------------------------------
void CPsClientTestSuite::HandlePsError(TInt /*aErrorCode*/)
{
}
// -----------------------------------------------------------------------------
// This function introduces a delay of the specified time in microseconds
// -----------------------------------------------------------------------------
void CPsClientTestSuite::RTimerWait(TTimeIntervalMicroSeconds32 aInterval)
{
TRequestStatus timerStatus;
iTimer.Cancel();
iTimer.After( timerStatus, aInterval);
User::WaitForRequest( timerStatus );
}
// -----------------------------------------------------------------------------
// Delete all contacts from the phonebook
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::DeleteAllContactsInPhonebookL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
//Wait for one second
RTimerWait(KOneSecDelay);
// Get all the contents and delete them
iCurrentOperation = EDeleteSearchedResults;
iPsClientHandler->GetAllContentsL();
CActiveScheduler::Start();
iReturnStatus = KErrNone;
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Checks the caching status of the psengine
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::CheckCachingStatusL()
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
TCachingStatus cachingStatus;
// We keep checking the caching status every second.
// Loop every second 100 times. If still caching is not complete,
// then there is some issue (Ideally the cahing should finish within a
// few seconds for 10-20 contacts.)
for(TInt i=0; i<100; i++)
{
iPsClientHandler->GetCachingStatusL(cachingStatus);
if(cachingStatus == ECachingComplete)
{
iReturnStatus = KErrNone;
break;
}
//Wait for one second
RTimerWait(KOneSecDelay);
}
// Return the status
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case performs a check for the version.
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::CheckVersion()
{
RTimerWait(KOneSecDelay);
TInt result = KErrNotFound;
// Get the version from the ps engine
TVersion ver = iPsClientHandler->Version(); // ver contains the version info of server
TInt major = ver.iMajor; // the major version number
TInt minor = ver.iMinor; // the minor version number
TInt build = ver.iBuild; // the build number
// compare the obtained value with the required value
if(major == 1 && minor == 0 && build == 0)
{
result = KErrNone;
}
return result; // return error code
}
// -----------------------------------------------------------------------------
// Tests the language support
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::TestIsLanguageSupportedL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Compare with expected result
if(iInputParsedData->LanguageInputExpectedResult() == iPsClientHandler->IsLanguageSupportedL(iInputParsedData->LanguageInput()))
{
iReturnStatus = KErrNone;
}
else
{
iReturnStatus = KErrGeneral;
}
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Gets all contacts from the phonebook
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::GetAllContentsL( CStifItemParser& aItem )
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
//Wait for one second
RTimerWait(KOneSecDelay);
iPsClientHandler->GetAllContentsL();
CActiveScheduler::Start();
// return error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Tests the sort order of the result data
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::TestSortOrderL( CStifItemParser& aItem )
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
//If more than one cacheuris are configured, then it is an error
HBufC* datastore = HBufC::NewL(50);
if(iInputParsedData->CacheUrisCount() ==1)
{
datastore->Des().Copy(iInputParsedData->CacheUris(0));
}
else
{
User::Leave(KErrArgument);
}
// Get the config file sort order
RArray<TInt> inputSortOrder;
iInputParsedData->SortOrder(inputSortOrder);
// If there are no elements in the sort order, then the existing sort order is
// used to set the sort order. This is added for test coverage
if(inputSortOrder.Count() == 0 )
{
iPsClientHandler->GetSortOrderL(*datastore,inputSortOrder);
}
//Set the sort order
iPsClientHandler->ChangeSortOrderL(*datastore,inputSortOrder);
RArray<TInt> newSortOrder;
// Get the sort order
iPsClientHandler->GetSortOrderL(*datastore,newSortOrder);
if(inputSortOrder.Count() != newSortOrder.Count())
{
iReturnStatus = KErrArgument;
delete datastore;
datastore = NULL;
return iReturnStatus;
}
for(TInt j =0; j < inputSortOrder.Count() ; j++ )
{
if(inputSortOrder[j] != newSortOrder[j] )
iReturnStatus = KErrArgument;
}
delete datastore;
datastore = NULL;
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Tests the sort order for error case
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::TestSortOrderErrCaseL( CStifItemParser& aItem )
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrNone;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
//If more than one cacheuris are configured, then it is an error
HBufC* datastore = HBufC::NewL(50);
if(iInputParsedData->CacheUrisCount() == 1)
{
datastore->Des().Copy(iInputParsedData->CacheUris(0));
}
else
{
User::Leave(KErrArgument);
}
// Get the config file sort order
RArray<TInt> inputSortOrder;
iInputParsedData->SortOrder(inputSortOrder);
//Set the sort order
iPsClientHandler->ChangeSortOrderL(*datastore,inputSortOrder);
RArray<TInt> newSortOrder;
// Get the sort order
iPsClientHandler->GetSortOrderL(*datastore,newSortOrder);
TChar equal = '=';
TInt pos = datastore->Des().Locate(equal);
if(pos != KErrNotFound)
{
HBufC* temp = datastore->Des().Left(pos + 1).AllocL();
if(temp->Des().Compare(groupformat) == 0 )
{
if(newSortOrder.Count() > 0)
{
iReturnStatus = KErrNone;
}
else
{
iReturnStatus = KErrArgument;
}
delete temp; temp = NULL;
}
}
else
{
if(newSortOrder.Count() == 0)
{
iReturnStatus = KErrNone;
}
else
{
iReturnStatus = KErrArgument;
}
}
delete datastore;
datastore = NULL;
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// Searches within a particular group.
// First get the group id from the group name. Then perform a search on the group
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::SearchWithInGroupL(CStifItemParser& aItem )
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
iGroupToBeSearchedId =0;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Search on the groups cache to get the group id of the input group
HBufC* grpDbUri = HBufC::NewL(50);
grpDbUri->Des().Copy(KVPbkDefaultGrpDbURI);
RPointerArray<TDesC> cacheUris;
cacheUris.AppendL(grpDbUri);
iInputParsedData->ApendCacheUrisL(cacheUris);
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
// Create the search query
iInputParsedData->CreateSearchQueryL(*iPsQuery, iInputParsedData->GroupToBeSearched());
iCurrentOperation = EGetGroupId;
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->SearchL(*iPsQuery);
CActiveScheduler::Start();
// Now the group Id is available, so create the search query.
// the group id is available in iGroupToBeSearchedId.
// Create a search uri using the group id
HBufC* grpSpecificUri = HBufC::NewL(50);
grpSpecificUri->Des().Copy(groupformat);
grpSpecificUri->Des().AppendNum(iGroupToBeSearchedId);
// Set the search group uri
RPointerArray<TDesC> grpCacheUris;
grpCacheUris.Append(grpSpecificUri);
iInputParsedData->ApendCacheUrisL(grpCacheUris);
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
// Create the search query
if(iPsQuery)
{
delete iPsQuery;
iPsQuery = CPsQuery::NewL();
}
iInputParsedData->CreateSearchQueryL(*iPsQuery, iInputParsedData->Query());
iCurrentOperation = EDefaultCase;
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->SearchL(*iPsQuery);
CActiveScheduler::Start();
// return the result
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case removes the observer for CPSRequestHandler
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::RemoveObserverL(CStifItemParser& /*aItem*/)
{
RTimerWait(KOneSecDelay);
TInt ret1 = KErrGeneral;
TInt ret2 = KErrGeneral;
//Remove the observer
ret1 = iPsClientHandler->RemoveObserver(this);
ret2 = iPsClientHandler->RemoveObserver(this);
if((ret1 == KErrNone)&& (ret2== KErrNotFound))
iReturnStatus = KErrNone;
else
iReturnStatus = KErrGeneral;
//return the result
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case converts and Id to vpbk link
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::ConvertToVpbkLinkL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrNone;
iCurrentOperation = EConvertToVpbkLink;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
//Get all the contents of the contacts
iPsClientHandler->GetAllContentsL();
CActiveScheduler::Start();
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case checks addition of marked contacts
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::AddMarkedContactsTestL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
iReturnStatus = KErrGeneral;
iCurrentOperation = EMarkedContacts;
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
// Perform the search settings
iInputParsedData->PerformSearchSettingsL(*iSettings);
// set search settings
iPsClientHandler->SetSearchSettingsL(*iSettings);
//Wait for one second
RTimerWait(KOneSecDelay);
iPsClientHandler->GetAllContentsL();
CActiveScheduler::Start();
//Now fire normal search query
iCurrentOperation = EDefaultCase;
// Create the search query
iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());
//Wait for one second
RTimerWait(KOneSecDelay);
//Perform the search
iPsClientHandler->SearchL(*iPsQuery,iMarkedContacts,NULL);
CActiveScheduler::Start();
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case tests the data order. This case cannot be checked from test
// suite. Added here for code coverage
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::TestDataOrderL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
//If more than one cacheuris are configured, then it is an error
HBufC* datastore = HBufC::NewL(50);
if(iInputParsedData->CacheUrisCount() ==1)
{
datastore->Des().Copy(iInputParsedData->CacheUris(0));
}
else
{
User::Leave(KErrArgument);
}
// Get the data order
RArray<TInt> myDataOrder;
iPsClientHandler->GetDataOrderL(*datastore, myDataOrder);
if(myDataOrder.Count() > 0)
{
iReturnStatus = KErrNone;
}
else
{
iReturnStatus = KErrGeneral;
}
delete datastore;
datastore = NULL;
//Return the error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case tests the data order. This case cannot be checked from test
// suite. Added here for code coverage
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::TestDataOrderForErrL(CStifItemParser& aItem)
{
RTimerWait(KOneSecDelay);
// Create the input parser
iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);
// Parse the input data
iInputParsedData->ParseInputL(aItem) ;
//If more than one cacheuris are configured, then it is an error
HBufC* datastore = HBufC::NewL(50);
if(iInputParsedData->CacheUrisCount() ==1)
{
datastore->Des().Copy(iInputParsedData->CacheUris(0));
}
else
{
User::Leave(KErrArgument);
}
// Get the data order
RArray<TInt> myDataOrder;
iPsClientHandler->GetDataOrderL(*datastore, myDataOrder);
if(myDataOrder.Count() == 0)
{
iReturnStatus = KErrNone;
}
else
{
iReturnStatus = KErrGeneral;
}
delete datastore;
datastore = NULL;
//Return the error code
return iReturnStatus;
}
// -----------------------------------------------------------------------------
// This test case performs shut down of the server
// -----------------------------------------------------------------------------
TInt CPsClientTestSuite::ShutDownL()
{
//Wait for one second
RTimerWait(KOneSecDelay); // wait for one sec
// Shut down the server
iPsClientHandler->ShutdownServerL(); // shutdown predictive search engine
// return the result
return KErrNone;
}
//End of files