1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Test step definitions for the PhoneBookStore functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21  

    22 #include <etelmm.h>

    23 

    24 #include "cetelsessionmgr.h"

    25 #include "cctsyintegrationtestphonebookstore.h" 

    26 

    27 const TInt KPBDataClientBuf10 = 500;

    28 const TInt KPBDataClientBuf50 = 2500;

    29 const TInt KPBDataClientBuf100 = 5000;

    30 

    31 //15 names and numbers

    32 _LIT16(KAnnText,"Ann");

    33 _LIT16(KMattSText,"MattS");

    34 _LIT16(KAndyText,"Andy");

    35 _LIT16(KMattMText,"MattM");

    36 _LIT16(KPaulText,"Paul");

    37 _LIT16(KMumAndDadText,"Mum and Dad");

    38 _LIT16(KHenrikText,"Henrik");

    39 _LIT16(KHenrikSVText,"HenrikSV");

    40 _LIT16(KMikaelText,"Mikael");

    41 _LIT16(KIngeText,"Inge");

    42 _LIT16(KAndersText,"Anders");

    43 _LIT16(KTextTooLong,"ABCDEFGHIJKLMNOPQRSTUVWXYZABCD");

    44 

    45 _LIT16(KAnnPhoneNum,"01632960000");

    46 _LIT16(KMattSPhoneNum,"01632960000");

    47 _LIT16(KAndyPhoneNum,"01632960000");

    48 _LIT16(KMattMPhoneNum,"01632960000");

    49 _LIT16(KPaulPhoneNum,"01632960000");

    50 _LIT16(KMumAndDadPhoneNum,"01632960000");

    51 _LIT16(KHenrikPhoneNum,"01632960000");

    52 _LIT16(KHenrikSVPhoneNum,"01632960000");

    53 _LIT16(KMikaelPhoneNum,"01632960000");

    54 _LIT16(KIngePhoneNum,"01632960000");

    55 _LIT16(KAndersPhoneNum,"01632960000");

    56 _LIT16(KNumberTooLong,"0171123456789012345678901234567331111114011111111150111111116011111111701111111180111");// needs to be over 80 since the  phone can take that many digits

    57 

    58 	

    59 CCTSYIntegrationTestPhoneBookStoreBase::CCTSYIntegrationTestPhoneBookStoreBase(CEtelSessionMgr& aEtelSessionMgr)

    60 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iSimTsyTestHelper(*this), iPhoneTsyTestHelper(*this), iNetworkTsyTestHelper(*this)

    61 /**

    62  * Constructor

    63  */

    64 	{

    65 	}

    66 

    67 CCTSYIntegrationTestPhoneBookStoreBase::~CCTSYIntegrationTestPhoneBookStoreBase()

    68 /*

    69  * Destructor

    70  */

    71 	{

    72 	}

    73 

    74 TBool CCTSYIntegrationTestPhoneBookStoreBase::EncodeTLVFormat(CPhoneBookBuffer* aPbBuffer

    75 		, TBuf<KBufSize>& aNumber, TUint8 aNumberType, TBuf<KBufSize>& aName)

    76 /**

    77  * member function for encoding in ASN.1 TLV(Tag-Length-Value) format taking four arguments and returning TBool value

    78  * 

    79  * @param aPbBuffer a CPhoneBookBuffer pointer to hold encoded binary stream

    80  * @param aNumber a reference to TBuf<KBufSize> holding phone number to be encoded

    81  * @param aNumberType a TUint8 argument holding type phone number to be encoded

    82  * @param aName a reference to TBuf<KBufSize> holding the name to be encoded

    83  *

    84  * @return ETrue if success, EFalse otherwise.

    85  */

    86 	{	

    87 	TBool functionExecutionStatus = ETrue; //Success

    88     TInt ret = aPbBuffer->AddNewEntryTag();

    89 	if(ret != KErrNone)

    90 		{	

    91 		DEBUG_PRINTF1(_L("CPhoneBookBuffer::AddNewEntryTag failed"));

    92 		functionExecutionStatus = EFalse;

    93 		}

    94 	ret = aPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBNumber

    95 			, aNumber);

    96 	if(ret != KErrNone)

    97 		{		

    98 		DEBUG_PRINTF1(_L("CPhoneBookBuffer::PutTagAndValue failed for number"));

    99 		functionExecutionStatus = EFalse;

   100 		}

   101 	// convert number type into TLV format and append it to allocated buffer

   102 	ret=aPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBTonNpi, aNumberType);

   103 	if(ret != KErrNone)

   104 		{	

   105 		DEBUG_PRINTF1(_L("CPhoneBookBuffer::PutTagAndValue failed for number type"));

   106 		functionExecutionStatus = EFalse;

   107 		}

   108 	// convert text into TLV format and append it to allocated buffer

   109 	ret=aPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBText, aName);

   110 	if(ret != KErrNone)

   111 		{	

   112 		DEBUG_PRINTF1(_L("CPhoneBookBuffer::PutTagAndValue failed for name"));

   113 		functionExecutionStatus = EFalse;

   114 		}

   115 	return functionExecutionStatus;

   116 	}

   117 

   118 TBool CCTSYIntegrationTestPhoneBookStoreBase::DecodeTLVFormat

   119 		(CPhoneBookBuffer* aPbBuffer, TInt aBufLen, TBuf<KBufSize>& aNumber

   120 				, TBuf<KBufSize>& aName, TInt aIndex)

   121 /**

   122  * member function for decoding a buffer in ASN.1 TLV(Tag-Length-Value) format taking five arguments and returning TBool value

   123  * 

   124  * @param aPbBuffer a CPhoneBookBuffer pointer to holding encoded binary stream to be decoded

   125  * @param aBufLen a TInt argument holding the length of the buffer to be decoded

   126  * @param aNumber a reference to TBuf<KBufSize> to hold decoded phone number

   127  * @param aName a reference to TBuf<KBufSize> to hold decoded name

   128  * @param aIndex a TInt argument holding the index of the record to be decoded

   129  *

   130  * @return ETrue if success, EFalse otherwise.

   131  */

   132 	{

   133 	TBool functionExecutionStatus = EFalse; //Failure

   134 	

   135 	TUint8 tagValue(0);

   136 	CPhoneBookBuffer::TPhBkTagType dataType;

   137 	TPtrC field(NULL,0);

   138 	

   139 	aPbBuffer->StartRead();       // Start reading received phonebook data

   140 	TInt offset = 0;

   141 	TInt pbRecordIndex = 0;

   142 	while(offset < aBufLen)

   143 		{

   144 		TInt ret = aPbBuffer->GetTagAndType(tagValue, dataType);

   145 		if( ret == KErrNotFound ) // Reached the end of phonebook data

   146 			{		

   147 			break;		

   148 			}

   149 			

   150 		switch(dataType)

   151 			{

   152 			case CPhoneBookBuffer::EPhBkTypeInt8:

   153 				{

   154 				TUint8 int8(0);

   155 				offset = offset + 1; // add tag-field only in case that is beginning of new field

   156 				if(tagValue == RMobilePhoneBookStore::ETagPBTonNpi)

   157 					{

   158 					aPbBuffer->GetValue(int8); //

   159 					offset = offset + 1; // 1-byte integer

   160 					}

   161 				}

   162 			break;

   163 

   164 			case CPhoneBookBuffer::EPhBkTypeInt16:

   165 				{

   166 				TUint16 int16(0);

   167 				aPbBuffer->GetValue(int16);

   168 				offset = offset + 3; // 2-byte integer + tag-field

   169 				}

   170 			break;

   171 

   172 			case CPhoneBookBuffer::EPhBkTypeInt32:

   173 				{

   174 				TUint32 int32(0);

   175 				aPbBuffer->GetValue(int32);

   176 				offset = offset + 5; // 4-byte integer + tag-field

   177 				}

   178 			break;

   179 

   180 			case CPhoneBookBuffer::EPhBkTypeDes16:

   181 				{				

   182 				aPbBuffer->GetValue(field);

   183 				offset = offset + field.Length() + 3; // add desc length + length-field + tag-field

   184 				if(tagValue == RMobilePhoneBookStore::ETagPBText)

   185 					{

   186 					aName = field;

   187 					}

   188 				else if(tagValue == RMobilePhoneBookStore::ETagPBNumber)

   189 					{

   190 					aNumber = field;	

   191 					pbRecordIndex++;

   192 					if(pbRecordIndex == aIndex)

   193 						{

   194 						functionExecutionStatus = ETrue;

   195 						return functionExecutionStatus;  //completed reading the required record

   196 						}

   197 					}

   198 				}

   199 				break;

   200 			default:

   201 				break;

   202 			} // end switch aDataType

   203 		} // end while

   204 	

   205 	return functionExecutionStatus;

   206 	}

   207 

   208 CCTSYIntegrationTestPhoneBookStore0001Base::CCTSYIntegrationTestPhoneBookStore0001Base(CEtelSessionMgr& aEtelSessionMgr)

   209 	: CCTSYIntegrationTestPhoneBookStoreBase(aEtelSessionMgr)

   210 /**

   211  * Constructor.

   212  */

   213 	{

   214 	

   215 	}

   216 

   217 CCTSYIntegrationTestPhoneBookStore0001Base::~CCTSYIntegrationTestPhoneBookStore0001Base()

   218 /**

   219  * Destructor.

   220  */

   221 	{

   222 	}

   223 

   224 void CCTSYIntegrationTestPhoneBookStore0001Base::DoTestProcedureL(TPhoneBookStoreId aPhoneBookId

   225 						,RMobilePhoneBookStore::TMobilePhoneBookLocation aExpectedPhoneBookLocation,

   226 						TUint32 aExpectedCaps)

   227 /**

   228  * TestDesc: Get phone store information.

   229  * TestExpectedResults: Pass - RMobilePhoneBookStore::TMobilePhoneBookInfoV1 returned with correct information.

   230  * Reason for test: Verify phone store information returned is correct.

   231  */

   232 	{

   233 

   234 	//

   235 	// SET UP

   236 	//

   237 

   238 	// Open the phone book subsession  

   239 	RMobilePhoneBookStore& phoneBookStore = iEtelSessionMgr.GetPhoneBookStoreL(KMainServer

   240 			, KMainPhone, aPhoneBookId);

   241 	RMmCustomAPI& mmCustomAPI = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone,KMainCustomApi);

   242 	iPhoneTsyTestHelper.WaitForPhoneBookStoreCacheReadyL(mmCustomAPI,aPhoneBookId);

   243 	

   244 	//

   245 	// SET UP END

   246 	//

   247 	

   248 	StartTest();

   249 	

   250 	//

   251 	// TEST START

   252 	//	

   253 

   254 	// Get the phone book store information with RMobilePhoneStore::GetInfo 

   255 	TExtEtelRequestStatus phoneStoreInfoStatus(phoneBookStore

   256 		, EMobilePhoneStoreGetInfo);

   257 	CleanupStack::PushL(phoneStoreInfoStatus);

   258 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfo;

   259 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phoneBookInfoPckg(phoneBookInfo);	

   260 	phoneBookStore.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   261 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneStoreInfoStatus

   262 		, ETimeShort), KErrNone, 	

   263 		_L("RMobilePhoneBookStore::GetInfo timed-out"));

   264 	ASSERT_EQUALS(phoneStoreInfoStatus.Int(), KErrNone,

   265 		 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   266 	// Check RMobilePhoneBookStore::TMobilePhoneBookInfoV1 (or derived class) returned contains:

   267 	// iType == RMobilePhoneStore::EPhoneBookStore 

   268 	// iTotalEntries >= -1 

   269 	// iUsedEntries >= -1 

   270 	// iMaxNumLength >= -1 

   271 	// iMaxTextLength >= -1 

   272 	ASSERT_EQUALS(phoneBookInfo.iType, RMobilePhoneStore::EPhoneBookStore,

   273 		_L("RMobilePhoneBookStore::GetInfo did not return RMobilePhoneStore::EPhoneBookStore."));

   274 	ASSERT_TRUE((phoneBookInfo.iTotalEntries >= -1),

   275 		_L("RMobilePhoneBookStore::GetInfo returned incorrect TotalEntries."));

   276 	ASSERT_TRUE((phoneBookInfo.iUsedEntries >= -1),

   277 		_L("RMobilePhoneBookStore::GetInfo returned incorrect UsedEntries."));

   278 	ASSERT_TRUE((phoneBookInfo.iMaxNumLength >= -1),

   279 		_L("RMobilePhoneBookStore::GetInfo returned incorrect MaxNumLength."));

   280 	ASSERT_TRUE((phoneBookInfo.iMaxTextLength >= -1),

   281 		_L("RMobilePhoneBookStore::GetInfo returned incorrect MaxTextLength."));

   282 

   283 	// If we are testing the BDN phonebook 

   284 	// iLocation == RMobilePhoneBookStore::ELocationUnknown 

   285 	// otherwise check 

   286 	// iLocation == RMobilePhoneBookStore::ELocationIccMemory 	

   287 	ASSERT_EQUALS(phoneBookInfo.iLocation

   288 		, aExpectedPhoneBookLocation,

   289 		_L("RMobilePhoneBookStore::GetInfo returned incorrect Location information."));

   290 

   291 	// Check iCaps for the following depending on which phone book is currently being tested:

   292 	// ADN phone book: iCaps == RMobilePhoneStore::KCapsReadAccess | RMobilePhoneStore::KCapsWriteAccess | RMobilePhoneStore::KCapsDeleteAll | RMobilePhoneStore::KCapsNotifyEvent 

   293 	// FDN phone book: iCaps == RMobilePhoneStore::KCapsReadAccess | RMobilePhoneStore::KCapsWriteAccess | RMobilePhoneStore::KCapsDeleteAll | RMobilePhoneStore::KCapsNotifyEvent | RMobilePhoneBookStore::KCapsRestrictedWriteAccess 

   294 	// VMBX (voice mail box) phone book: iCaps == RMobilePhoneStore::KCapsReadAccess | RMobilePhoneStore::KCapsWriteAccess | RMobilePhoneStore::KCapsDeleteAll | RMobilePhoneStore::KCapsNotifyEvent 

   295 	// SDN phone book: iCaps == RMobilePhoneStore::KCapsReadAccess 

   296 	// BDN phone book: iCaps == 0 

   297 	// MBDN (mailbox dialling numbers) phone book: iCaps == RMobilePhoneStore::KCapsReadAccess | RMobilePhoneStore::KCapsWriteAccess 

   298 	ASSERT_BITS_SET(phoneBookInfo.iCaps, aExpectedCaps, KNoUnwantedBits, 

   299 		_L("RMobilePhoneBookStore::GetInfo returned incorrect caps"));

   300 	

   301 	

   302 	//

   303 	// TEST END

   304 	//

   305 

   306     StartCleanup();

   307 	

   308 	CleanupStack::PopAndDestroy(&phoneStoreInfoStatus);

   309 	

   310 	}

   311 

   312 

   313 CCTSYIntegrationTestPhoneBookStore0002Base::CCTSYIntegrationTestPhoneBookStore0002Base(CEtelSessionMgr& aEtelSessionMgr)

   314 	: CCTSYIntegrationTestPhoneBookStoreBase(aEtelSessionMgr)

   315 /**

   316  * Constructor.

   317  */

   318 	{

   319 	

   320 	}

   321 

   322 CCTSYIntegrationTestPhoneBookStore0002Base::~CCTSYIntegrationTestPhoneBookStore0002Base()

   323 /**

   324  * Destructor.

   325  */

   326 	{

   327 	}

   328 

   329 void CCTSYIntegrationTestPhoneBookStore0002Base::DoTestProcedureL(TPhoneBookStoreId aPhoneBookId)

   330 /**

   331  * TestDesc: Read single and multiple phonebook entries.

   332  * TestExpectedResults: Pass - Single and multiple entries read successfully.

   333  * Reason for test: Verify single and multiple entries can be read and entry information is correct.

   334  */

   335 	{

   336 

   337 	//

   338 	// SET UP

   339 	//

   340 

   341 	

   342 	// Ensure RMobilePhoneStore::GetInfo returns iCaps in set of KCapsWriteAccess | KCapsReadAccess | KCapsDeleteAll 

   343 	RMobilePhoneBookStore& phoneBookStore = iEtelSessionMgr.GetPhoneBookStoreL

   344 		(KMainServer, KMainPhone, aPhoneBookId);

   345 	RMmCustomAPI& mmCustomAPI = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone,KMainCustomApi);

   346 	iPhoneTsyTestHelper.WaitForPhoneBookStoreCacheReadyL(mmCustomAPI,aPhoneBookId);

   347 

   348 	

   349 	TExtEtelRequestStatus phoneStoreInfoStatus(phoneBookStore

   350 		, EMobilePhoneStoreGetInfo);

   351 	CleanupStack::PushL(phoneStoreInfoStatus);

   352 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfo;

   353 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phoneBookInfoPckg(phoneBookInfo);	

   354 	phoneBookStore.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   355 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneStoreInfoStatus, ETimeShort), KErrNone, 

   356 		_L("RMobilePhoneBookStore::GetInfo timed-out"));

   357 	CHECK_EQUALS_L(phoneStoreInfoStatus.Int(),  KErrNone,

   358 		 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   359 	TUint32 expectedCaps = RMobilePhoneStore::KCapsWriteAccess

   360 							| RMobilePhoneStore::KCapsReadAccess

   361 							| RMobilePhoneStore::KCapsDeleteAll;

   362 	CHECK_BITS_SET_L(phoneBookInfo.iCaps, expectedCaps, KNoUnwantedBits,

   363 		_L("RMobilePhoneBookStore::GetInfo returned incorrect caps"));

   364 		

   365 	// Delete all entries from the phone book with RMobilePhoneBookStore::DeleteAll 

   366 	TExtEtelRequestStatus deleteStoreStatus(phoneBookStore

   367 		, EMobilePhoneStoreDeleteAll);

   368 	CleanupStack::PushL(deleteStoreStatus);

   369 	phoneBookStore.DeleteAll(deleteStoreStatus);	

   370 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(deleteStoreStatus, ETimeVeryLong), KErrNone, 

   371 		_L("RMobilePhoneBookStore::DeleteAll timed-out"));

   372 	CHECK_TRUE_L((deleteStoreStatus.Int()==KErrNone 

   373 		|| deleteStoreStatus.Int() == KErrNotFound),

   374 		_L("RMobilePhoneBookStore::DeleteAll returned with an error."))

   375 

   376 	// Write entries into the first 10 slots of the phone book. 

   377 	const TUint32 count = 10;	

   378 	TFixedArray<TBuf<KBufSize>,count> names;

   379 	TFixedArray<TBuf<KBufSize>,count> numbers;	

   380 	names[0].Copy(KAnnText);

   381 	numbers[0].Copy(KAnnPhoneNum);

   382 	names[1].Copy(KMattSText);

   383 	numbers[1].Copy(KMattSPhoneNum);

   384 	names[2].Copy(KAndyText);

   385 	numbers[2].Copy(KAndyPhoneNum);

   386 	names[3].Copy(KMattMText);

   387 	numbers[3].Copy(KMattMPhoneNum);

   388 	names[4].Copy(KPaulText);

   389 	numbers[4].Copy(KPaulPhoneNum);

   390 	names[5].Copy(KMumAndDadText);

   391 	numbers[5].Copy(KMumAndDadPhoneNum);

   392 	names[6].Copy(KHenrikText);

   393 	numbers[6].Copy(KHenrikPhoneNum);

   394 	names[7].Copy(KHenrikSVText);

   395 	numbers[7].Copy(KHenrikSVPhoneNum);

   396 	names[8].Copy(KMikaelText);

   397 	numbers[8].Copy(KMikaelPhoneNum);

   398 	names[9].Copy(KIngeText);

   399 	numbers[9].Copy(KIngePhoneNum);	

   400 	TBuf8<KPBDataClientBuf10> pbData;  // Client reserved space for phonebook data

   401 	CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer(); // used to write phonebook data

   402 	CleanupStack::PushL(pbBuffer);

   403 	pbBuffer->Set(&pbData); // Set it to point to the Client buffer

   404 	for(TInt i=1;i<=count;++i)

   405 		{

   406 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

   407 		pbData.FillZ();

   408 		pbData.Zero();

   409 		TBool ret = EncodeTLVFormat(pbBuffer, numbers[i-1], (TUint8)RMobilePhone::EUnknownNumber

   410 				, names[i-1]);

   411 		CHECK_TRUE_L(ret,_L("EncodeTLVFormat failed"));	

   412 		TExtEtelRequestStatus phoneBookWriteStatus(phoneBookStore

   413 								, EMobilePhoneBookStoreWrite);

   414 		CleanupStack::PushL(phoneBookWriteStatus);

   415 		phoneBookStore.Write(phoneBookWriteStatus, pbData, i);		

   416 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneBookWriteStatus

   417 				, ETimeMedium), KErrNone,

   418 				_L("RMobilePhoneBookStore::Write timed-out"));

   419 		CHECK_EQUALS_L(phoneBookWriteStatus.Int(), KErrNone, 

   420 			_L("RMobilePhoneBookStore::Write returned with an error"));

   421 		CleanupStack::PopAndDestroy(&phoneBookWriteStatus);

   422 		}

   423 

   424 	//

   425 	// SET UP END

   426 	//

   427 	

   428 	StartTest();

   429 	

   430 	//

   431 	// TEST START

   432 	//

   433 	

   434 	

   435 	// ===  Read single entry from each of filled slots ===

   436 

   437 	for(TInt i = 1; i <= count; ++i)

   438 		{

   439 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

   440 		pbData.FillZ();

   441 		pbData.Zero();		

   442 		TExtEtelRequestStatus phoneBookReadStatus(phoneBookStore

   443 			, EMobilePhoneBookStoreRead);	

   444 		CleanupStack::PushL(phoneBookReadStatus);

   445 		

   446 		// For each of the filled phone book slots, read a single entry from the phone book using RMobilePhoneBookStore::Read and setting aNumSlots = 1		

   447 		phoneBookStore.Read(phoneBookReadStatus, i, 1, pbData);

   448 		ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   449 			, ETimeMedium), KErrNone,

   450 			_L("RMobilePhoneBookStore::Read timed-out"));

   451 		ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNone, 

   452 			_L("RMobilePhoneBookStore::Read returned with an error"));

   453 

   454 		// Check that the aPBData TLV descriptor returned contains correct entry information.

   455 		TBuf<KBufSize> readNumber;

   456 		TBuf<KBufSize> readName;		

   457 		TInt bufLen = pbData.Length(); 

   458 

   459 		// decode PB data received in TLV format		

   460 		TBool ret = DecodeTLVFormat(pbBuffer, bufLen, readNumber, readName, 1);

   461 		ASSERT_TRUE(ret, _L("DecodeTLVFormat failed"))				

   462 		ASSERT_EQUALS_DES16(numbers[i-1], readNumber,

   463 			_L("RMobilePhoneBookStore::Read completed with incorrect number"));

   464 		ASSERT_EQUALS_DES16(names[i-1], readName,

   465 			_L("RMobilePhoneBookStore::Read completed with incorrect name"));		

   466 		CleanupStack::PopAndDestroy(&phoneBookReadStatus);

   467 		}

   468 	// ===  Read five entries where all requested slots are filled ===

   469 	// Read 5 entries from the phone book using RMobilePhoneBookStore::Read with aNumSlots = 5 and using aIndex = 1, aIndex = 5 

   470 	// Read from phone book starting from aIndex=1 reading 5 slots

   471 

   472 	pbData.FillZ();

   473 	pbData.Zero();	

   474 	TExtEtelRequestStatus phoneBookReadStatus(phoneBookStore

   475 			, EMobilePhoneBookStoreRead);	

   476 	CleanupStack::PushL(phoneBookReadStatus);

   477 	phoneBookStore.Read(phoneBookReadStatus, 1, 5, pbData);

   478 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   479 			, ETimeMedium), KErrNone,

   480 			_L("RMobilePhoneBookStore::Read timed-out"));

   481 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNone, 

   482 			_L("RMobilePhoneBookStore::Read returned with an error"));

   483 	TInt bufLen = pbData.Length(); 

   484 	// Check that the aPBData TLV descriptor returned contains 5 entries with correct entry information.

   485 	for(TInt i = 1; i <= 5; ++i)

   486 		{

   487 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

   488 		TBuf<KBufSize> readNumber;

   489 		TBuf<KBufSize> readName;		

   490 		// decode PB data received in TLV format		

   491 		TBool ret = DecodeTLVFormat(pbBuffer, bufLen, readNumber, readName, i);

   492 		ASSERT_TRUE(ret, _L("DecodeTLVFormat failed"));

   493 

   494 		ASSERT_EQUALS_DES16(numbers[i-1], readNumber,

   495 			_L("RMobilePhoneBookStore::Read completed with incorrect number"));

   496 		ASSERT_EQUALS_DES16(names[i-1], readName,

   497 			_L("RMobilePhoneBookStore::Read completed with incorrect name"));

   498 		}

   499 

   500 	// Read from phone book starting from aIndex=5 reading 5 slots

   501 	pbData.FillZ();

   502 	pbData.Zero();	

   503 	phoneBookStore.Read(phoneBookReadStatus, 5, 5, pbData);

   504 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   505 			, ETimeMedium), KErrNone,

   506 			_L("RMobilePhoneBookStore::Read timed-out"));

   507 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNone, 

   508 			_L("RMobilePhoneBookStore::Read returned with an error"));

   509 	bufLen = pbData.Length();

   510 	for(TInt i = 1; i <= 5; ++i)

   511 		{

   512 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

   513 		TBuf<KBufSize> readNumber;

   514 		TBuf<KBufSize> readName;		

   515 		// decode PB data received in TLV format		

   516 		TBool ret = DecodeTLVFormat(pbBuffer, bufLen, readNumber, readName, i);

   517 		ASSERT_TRUE(ret,_L("DecodeTLVFormat failed"));

   518 		ASSERT_EQUALS_DES16(numbers[(i+4)-1], readNumber,

   519 			_L("RMobilePhoneBookStore::Read completed with incorrect number"));

   520 		ASSERT_EQUALS_DES16(names[(i+4)-1], readName,

   521 			_L("RMobilePhoneBookStore::Read completed with incorrect name"));		

   522 		}	

   523 

   524 	// ===  Read five entries where some of requested slots are filled ===

   525 	// Read 5 entries from the phone book using RMobilePhoneBookStore::Read with aNumSlots = 5 and using aIndex = 7 

   526 	pbData.FillZ();

   527 	pbData.Zero();	

   528 	phoneBookStore.Read(phoneBookReadStatus, 7, 5, pbData);

   529 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   530 			, ETimeMedium), KErrNone,

   531 			_L("RMobilePhoneBookStore::Read timed-out"));

   532 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNone, 

   533 			_L("RMobilePhoneBookStore::Read returned with an error"));

   534 	bufLen = pbData.Length();

   535 	// Check that the aPBData TLV descriptor returned contains 4 entries with correct entry information.

   536 	for(TInt i = 1; i <= 5; ++i)

   537 		{

   538 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

   539 		TBuf<KBufSize> readNumber;

   540 		TBuf<KBufSize> readName;		

   541 		// decode PB data received in TLV format		

   542 		TBool ret = DecodeTLVFormat(pbBuffer, bufLen, readNumber, readName, i);

   543 		

   544 		// For first 4 entries, check that received entry is same as that written 

   545 		if(i < 5)

   546 			{

   547 			ASSERT_TRUE(ret,_L("DecodeTLVFormat failed"));

   548 			ASSERT_EQUALS_DES16(numbers[(i+6)-1], readNumber,

   549 				_L("RMobilePhoneBookStore::Read completed with incorrect number"));

   550 			ASSERT_EQUALS_DES16(names[(i+6)-1], readName,

   551 				_L("RMobilePhoneBookStore::Read completed with incorrect name"));

   552 			}

   553 		else

   554 			{

   555 			ASSERT_TRUE(!ret,_L("test found more entries than was expected"));

   556 			}

   557 		}

   558 	

   559 	//

   560 	// TEST END

   561 	//

   562 

   563     StartCleanup();

   564     

   565 	// 1 phoneStoreInfoStatus

   566 	// 2 deleteStoreStatus

   567 	// 3 pbBuffer

   568 	// 4 phoneBookReadStatus	

   569 	CleanupStack::PopAndDestroy(4,&phoneStoreInfoStatus);	

   570 	

   571 	}

   572 

   573 

   574 CCTSYIntegrationTestPhoneBookStore0003Base::CCTSYIntegrationTestPhoneBookStore0003Base(CEtelSessionMgr& aEtelSessionMgr)

   575 	: CCTSYIntegrationTestPhoneBookStoreBase(aEtelSessionMgr)

   576 /**

   577  * Constructor.

   578  */

   579 	{

   580 	

   581 	}

   582 

   583 CCTSYIntegrationTestPhoneBookStore0003Base::~CCTSYIntegrationTestPhoneBookStore0003Base()

   584 /**

   585  * Destructor.

   586  */

   587 	{

   588 	}

   589 

   590 void CCTSYIntegrationTestPhoneBookStore0003Base::DoTestProcedureL(TPhoneBookStoreId aPhoneBookId)

   591 /**

   592  * TestDesc: Read single and multiple phonebook entries which are not present.

   593  * TestExpectedResults: Pass - KErrNotFound returned.

   594  * Reason for test: Verify KErrNotFound is returned.

   595  */

   596 	{

   597 

   598 	//

   599 	// SET UP

   600 	//

   601 	// Get the phone store information with Ensure RMobilePhoneStore::GetInfo returns iCaps in set of KCapsReadAccess | KCapsDeleteAll 

   602 	RMobilePhoneBookStore& phoneBookStore = iEtelSessionMgr.GetPhoneBookStoreL(KMainServer

   603 			, KMainPhone, aPhoneBookId);

   604 	RMmCustomAPI& mmCustomAPI = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone,KMainCustomApi);

   605 	iPhoneTsyTestHelper.WaitForPhoneBookStoreCacheReadyL(mmCustomAPI,aPhoneBookId);

   606 	TExtEtelRequestStatus phoneStoreInfoStatus(phoneBookStore

   607 		, EMobilePhoneStoreGetInfo);

   608 	CleanupStack::PushL(phoneStoreInfoStatus);

   609 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfo;

   610 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phoneBookInfoPckg(phoneBookInfo);	

   611 	phoneBookStore.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   612 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneStoreInfoStatus, ETimeShort), KErrNone, 

   613 		_L("RMobilePhoneBookStore::GetInfo timed-out"));

   614 	CHECK_EQUALS_L(phoneStoreInfoStatus.Int(),  KErrNone,

   615 		 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   616 	TUint32 expectedCaps = RMobilePhoneStore::KCapsWriteAccess

   617 							| RMobilePhoneStore::KCapsReadAccess

   618 							| RMobilePhoneStore::KCapsDeleteAll;

   619 	CHECK_BITS_SET_L(phoneBookInfo.iCaps, expectedCaps, KNoUnwantedBits,

   620 		_L("RMobilePhoneBookStore::GetInfo returned incorrect caps"));

   621 		

   622 	// Delete all entries from the phone book with RMobilePhoneBookStore::DeleteAll 

   623 	TExtEtelRequestStatus deleteStoreStatus(phoneBookStore

   624 		, EMobilePhoneStoreDeleteAll);

   625 	CleanupStack::PushL(deleteStoreStatus);

   626 	phoneBookStore.DeleteAll(deleteStoreStatus);	

   627 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(deleteStoreStatus, ETimeVeryLong), KErrNone, 

   628 		_L("RMobilePhoneBookStore::DeleteAll timed-out"));

   629 	CHECK_TRUE_L((deleteStoreStatus.Int()==KErrNone 

   630 		|| deleteStoreStatus.Int() == KErrNotFound),

   631 		_L("RMobilePhoneBookStore::DeleteAll returned with an error."));

   632 

   633 	// Get the phone store information and check iUsedEntries = 0, store the value of iTotalEntries. 

   634 	phoneBookStore.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   635 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneStoreInfoStatus, ETimeShort), KErrNone, 

   636 		_L("RMobilePhoneBookStore::GetInfo timed-out"));

   637 	CHECK_EQUALS_L(phoneStoreInfoStatus.Int(),  KErrNone,

   638 		 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   639 	CHECK_EQUALS_L(phoneBookInfo.iUsedEntries, 0, 

   640 		_L("RMobilePhoneBookStore::GetInfo returned iUsedEntries not equal to zero"));

   641 

   642 	//

   643 	// SET UP END

   644 	//

   645 	

   646 	StartTest();

   647 	

   648 	//

   649 	// TEST START

   650 	//

   651 		

   652 	// ===  Read single entry from first slot ===

   653 	TBuf8<KPBDataClientBuf10> pbData; // Client reserved space for phonebook data

   654 	CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer(); // used to write phonebook data

   655 	CleanupStack::PushL(pbBuffer);

   656 	pbBuffer->Set(&pbData); // Set it to point to the Client buffer

   657 

   658 	// Read a single entry from the phone book using aNumSlots=1 and aIndex = 1 

   659 	pbData.FillZ();

   660 	pbData.Zero();	

   661 	TExtEtelRequestStatus phoneBookReadStatus(phoneBookStore

   662 			, EMobilePhoneBookStoreRead);	

   663 	CleanupStack::PushL(phoneBookReadStatus);

   664 

   665 	phoneBookStore.Read(phoneBookReadStatus, 1, 1, pbData);

   666 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   667 			, ETimeMedium), KErrNone,

   668 			_L("RMobilePhoneBookStore::Read timed-out"));

   669 	

   670 	// Check KErrNotFound is returned.

   671 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNotFound, 

   672 			_L("RMobilePhoneBookStore::Read returned with an error"));

   673 

   674 	// ===  Read single entry from middle of phone book ===

   675 

   676 	// Read a single entry from the phone book using aNumSlots=1 and aIndex = 10 

   677 	phoneBookStore.Read(phoneBookReadStatus, 10, 1, pbData);

   678 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   679 			, ETimeMedium), KErrNone,

   680 			_L("RMobilePhoneBookStore::Read timed-out"));

   681 	

   682 	// Check KErrNotFound is returned.

   683 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNotFound, 

   684 			_L("RMobilePhoneBookStore::Read returned with an error"));

   685 

   686 	// ===  Read single entry from end of phone book ===

   687 

   688 	// Read a single entry from the phone book using aNumSlots=1 and aIndex = iTotalEntries 

   689 	phoneBookStore.Read(phoneBookReadStatus, phoneBookInfo.iTotalEntries, 1, pbData);

   690 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   691 			, ETimeMedium), KErrNone,

   692 			_L("RMobilePhoneBookStore::Read timed-out"));

   693 	

   694 	// Check KErrNotFound is returned.

   695 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNotFound, 

   696 			_L("RMobilePhoneBookStore::Read returned with an error"));

   697 

   698 	// ===  Read multiple entries starting from first index ===

   699 

   700 	// Read 5 entries from the phone book using aNumSlots = 5 and aIndex = 1. 

   701 	phoneBookStore.Read(phoneBookReadStatus, 1, 5, pbData);

   702 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   703 			, ETimeMedium), KErrNone,

   704 			_L("RMobilePhoneBookStore::Read timed-out"));

   705 	

   706 	// Check KErrNotFound is returned.

   707 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNotFound, 

   708 			_L("RMobilePhoneBookStore::Read returned with an error"));

   709 

   710 	// ===  Read multiple entries starting from middle of phone book ===

   711 

   712 	// Read 5 entries from the phone book using aNumSlots = 5 and aIndex = 10. 

   713 	phoneBookStore.Read(phoneBookReadStatus, 10, 5, pbData);

   714 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   715 			, ETimeMedium), KErrNone,

   716 			_L("RMobilePhoneBookStore::Read timed-out"));

   717 	

   718 	// Check KErrNotFound is returned.

   719 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNotFound, 

   720 			_L("RMobilePhoneBookStore::Read returned with an error"));

   721 			

   722 	// ===  Read multiple entries up to the end of the phone book ===

   723 

   724 	// Read 5 entries from the phone book using aNumSlots = 5 and aIndex = iTotalEntries-5. 

   725 	phoneBookStore.Read(phoneBookReadStatus, phoneBookInfo.iTotalEntries-5, 5, pbData);

   726 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   727 			, ETimeMedium), KErrNone,

   728 			_L("RMobilePhoneBookStore::Read timed-out"));

   729 	

   730 	// Check KErrNotFound is returned.

   731 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrNotFound, 

   732 			_L("RMobilePhoneBookStore::Read returned with an error"));

   733 

   734 	// ===  Read multiple entries going over the end of the phone book ===

   735 

   736 	// Read 5 entries from the phone book using aNumSlots = 5 and aIndex = iTotalEntries-2. 

   737 	phoneBookStore.Read(phoneBookReadStatus, phoneBookInfo.iTotalEntries-2, 5, pbData);

   738 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   739 			, ETimeMedium), KErrNone,

   740 			_L("RMobilePhoneBookStore::Read timed-out"));

   741 	

   742 	// Check KErrNotFound or KErrArgument is returned

   743 	ASSERT_TRUE( ( phoneBookReadStatus.Int() == KErrArgument

   744 					|| phoneBookReadStatus.Int() == KErrNotFound ), 

   745 			_L("RMobilePhoneBookStore::Read returned with an error"));

   746 	

   747 	//

   748 	// TEST END

   749 	//

   750 

   751     StartCleanup();

   752 	

   753 	//1 phoneStoreInfoStatus

   754 	//2 deleteStoreStatus

   755 	//3 pbBuffer

   756 	//4 phoneBookReadStatus

   757 	CleanupStack::PopAndDestroy(4,&phoneStoreInfoStatus);

   758 	

   759 	}

   760 

   761 

   762 CCTSYIntegrationTestPhoneBookStore0004Base::CCTSYIntegrationTestPhoneBookStore0004Base(CEtelSessionMgr& aEtelSessionMgr)

   763 	: CCTSYIntegrationTestPhoneBookStoreBase(aEtelSessionMgr)

   764 /**

   765  * Constructor.

   766  */

   767 	{

   768 	

   769 	}

   770 

   771 CCTSYIntegrationTestPhoneBookStore0004Base::~CCTSYIntegrationTestPhoneBookStore0004Base()

   772 /**

   773  * Destructor.

   774  */

   775 	{

   776 	}

   777 

   778 void CCTSYIntegrationTestPhoneBookStore0004Base::DoTestProcedureL(TPhoneBookStoreId aPhoneBookId)

   779 /**

   780   *TestDesc: Read phonebook entry using invalid index.

   781  * TestExpectedResults: Pass - KErrArgument returned.

   782  * Reason for test: Verify KErrArgument returned.

   783  */

   784 	{

   785 

   786 	//

   787 	// SET UP

   788 	//

   789 	// Ensure RMobilePhoneStore::GetInfo returns iCaps in set of KCapsReadAccess 

   790 	RMobilePhoneBookStore& phoneBookStore = iEtelSessionMgr.GetPhoneBookStoreL(KMainServer

   791 			, KMainPhone, aPhoneBookId);

   792 	RMmCustomAPI& mmCustomAPI = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone,KMainCustomApi);

   793 	iPhoneTsyTestHelper.WaitForPhoneBookStoreCacheReadyL(mmCustomAPI,aPhoneBookId);

   794 	TExtEtelRequestStatus phoneStoreInfoStatus(phoneBookStore

   795 		, EMobilePhoneStoreGetInfo);

   796 	CleanupStack::PushL(phoneStoreInfoStatus);

   797 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfo;

   798 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phoneBookInfoPckg(phoneBookInfo);	

   799 	phoneBookStore.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   800 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneStoreInfoStatus, ETimeShort), KErrNone, 

   801 		_L("RMobilePhoneBookStore::GetInfo timed-out"));

   802 	CHECK_EQUALS_L(phoneStoreInfoStatus.Int(),  KErrNone,

   803 		 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   804 	TUint32 expectedCaps = RMobilePhoneStore::KCapsReadAccess;

   805 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10040);

   806 	CHECK_BITS_SET_L(phoneBookInfo.iCaps, expectedCaps, KNoUnwantedBits,

   807 		_L("RMobilePhoneBookStore::GetInfo returned incorrect caps"));

   808 

   809 	//

   810 	// SET UP END

   811 	//

   812 	

   813 	StartTest();

   814 	

   815 	//

   816 	// TEST START

   817 	//

   818 	

   819 	

   820 	// ===  Read an entry with an invalid slot number ===

   821 	TBuf8<KPBDataClientBuf10> pbData; // Client reserved space for phonebook data

   822 	CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer(); // used to write phonebook data

   823 	CleanupStack::PushL(pbBuffer);

   824 	pbBuffer->Set(&pbData); // Set it to point to the Client buffer

   825 

   826 	// Read a single entry from the phone book using aNumSlots=1 and aIndex = -1 

   827 	TExtEtelRequestStatus phoneBookReadStatus(phoneBookStore

   828 			, EMobilePhoneBookStoreRead);	

   829 	CleanupStack::PushL(phoneBookReadStatus);

   830 

   831 	phoneBookStore.Read(phoneBookReadStatus, -1, 1, pbData);

   832 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   833 			, ETimeMedium), KErrNone,

   834 			_L("RMobilePhoneBookStore::Read timed-out"));

   835 	

   836 	// Check KErrArgument is returned.

   837 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrArgument, 

   838 			_L("RMobilePhoneBookStore::Read returned with an error"));

   839 

   840 	// Read a single entry from the phone book using aNumSlots=1 and aIndex = -10 

   841 	phoneBookStore.Read(phoneBookReadStatus, -10, 1, pbData);

   842 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   843 			, ETimeMedium), KErrNone,

   844 			_L("RMobilePhoneBookStore::Read timed-out"));

   845 	

   846 	// Check KErrArgument is returned.

   847 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrArgument, 

   848 			_L("RMobilePhoneBookStore::Read returned with an error"));

   849 

   850 	// Read a single entry from the phone book using aNumSlots=10 and aIndex = -50 

   851 	phoneBookStore.Read(phoneBookReadStatus, -50, 10, pbData);

   852 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   853 			, ETimeMedium), KErrNone,

   854 			_L("RMobilePhoneBookStore::Read timed-out"));

   855 	

   856 	// Check KErrArgument is returned.

   857 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrArgument, 

   858 			_L("RMobilePhoneBookStore::Read returned with an error"));

   859 

   860 	// ===  Read an entry with an invalid value for aNumSlots ===

   861 

   862 	// Read a single entry from the phone book using aNumSlots=0 and aIndex = 1 

   863 	phoneBookStore.Read(phoneBookReadStatus, 1, 0, pbData);

   864 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   865 			, ETimeMedium), KErrNone,

   866 			_L("RMobilePhoneBookStore::Read timed-out"));

   867 	

   868 	// Check KErrArgument is returned.

   869 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrArgument, 

   870 			_L("RMobilePhoneBookStore::Read returned with an error"));

   871 

   872 	// Read a single entry from the phone book using aNumSlots=-1 and aIndex = 1 

   873 	phoneBookStore.Read(phoneBookReadStatus, 1, -1, pbData);

   874 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   875 			, ETimeMedium), KErrNone,

   876 			_L("RMobilePhoneBookStore::Read timed-out"));

   877 	

   878 	// Check KErrArgument is returned.

   879 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrArgument, 

   880 			_L("RMobilePhoneBookStore::Read returned with an error"));

   881 

   882 	// Read a single entry from the phone book using aNumSlots=-10 and aIndex = 10 

   883 	phoneBookStore.Read(phoneBookReadStatus, 10, -10, pbData);

   884 	ASSERT_EQUALS(WaitForRequestWithTimeOut(phoneBookReadStatus

   885 			, ETimeMedium), KErrNone,

   886 			_L("RMobilePhoneBookStore::Read timed-out"));

   887 	

   888 	// Check KErrArgument is returned.

   889 	ASSERT_EQUALS(phoneBookReadStatus.Int(), KErrArgument, 

   890 			_L("RMobilePhoneBookStore::Read returned with an error"));

   891 

   892 	//

   893 	// TEST END

   894 	//

   895 

   896     StartCleanup();

   897 	

   898 	//1 phoneStoreInfoStatus

   899 	//2 pbBuffer

   900 	//3 phoneBookReadStatus

   901 	CleanupStack::PopAndDestroy(3,&phoneStoreInfoStatus);

   902 	

   903 	}

   904 

   905 

   906 CCTSYIntegrationTestPhoneBookStore0005Base::CCTSYIntegrationTestPhoneBookStore0005Base(CEtelSessionMgr& aEtelSessionMgr)

   907 	: CCTSYIntegrationTestPhoneBookStoreBase(aEtelSessionMgr)

   908 /**

   909  * Constructor.

   910  */

   911 	{

   912 	

   913 	}

   914 

   915 CCTSYIntegrationTestPhoneBookStore0005Base::~CCTSYIntegrationTestPhoneBookStore0005Base()

   916 /**

   917  * Destructor.

   918  */

   919 	{

   920 	}

   921 

   922 void CCTSYIntegrationTestPhoneBookStore0005Base::DoTestProcedureL(TFixedArray<TPhoneBookStoreId,2>& aPhoneBookTypeArray)

   923 /**

   924  * TestDesc: Read and write multiple phonebooks simultaneously.

   925  * TestExpectedResults: Pass - Numbers read successfully.

   926  * Reason for test: Verify it is possible to post read/write requests simultaneously to different phone books.

   927  */

   928 	{

   929 

   930 	//

   931 	// SET UP

   932 	//

   933 

   934 	const TInt noOfPhoneBooks = 2;

   935 	//	Not supported - KMeDialledPhoneBook, KMeMissedPhoneBook, KMeReceivedPhoneBook, KCombinedAdnPhoneBook, KTaAdnPhoneBook, KIccFdnPhoneBook, KIccSdnPhoneBook, KIccBdnPhoneBook,KIccLndPhoneBook, KIccVoiceMailBox,	KIccLndPhoneBook

   936 	RMmCustomAPI& mmCustomAPI = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone,KMainCustomApi);

   937 	RMobilePhoneBookStore *phoneBookStore[noOfPhoneBooks];	

   938 	for(TInt i = 0; i< noOfPhoneBooks; ++i)

   939 		{

   940 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

   941 		RMobilePhoneBookStore& phoneBookStr = iEtelSessionMgr.GetPhoneBookStoreL(KMainServer, KMainPhone, aPhoneBookTypeArray[i]);		

   942 		iPhoneTsyTestHelper.WaitForPhoneBookStoreCacheReadyL(mmCustomAPI,aPhoneBookTypeArray[i]);		

   943 		phoneBookStore[i] = &phoneBookStr;		

   944 		TExtEtelRequestStatus phoneStoreInfoStatus(phoneBookStr

   945 				, EMobilePhoneStoreGetInfo);

   946 		CleanupStack::PushL(phoneStoreInfoStatus);

   947 		RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfo;

   948 		RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phoneBookInfoPckg(phoneBookInfo);	

   949 		phoneBookStr.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   950 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneStoreInfoStatus, ETimeShort), KErrNone, 

   951 			_L("RMobilePhoneBookStore::GetInfo timed-out"));

   952 		CHECK_EQUALS_L(phoneStoreInfoStatus.Int(),  KErrNone,

   953 			 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   954 		 // Ensure that SIM used is not full.

   955 		if (phoneBookInfo.iUsedEntries == phoneBookInfo.iTotalEntries)    

   956 			{

   957 			// delete some entries

   958 			TInt index = 1;

   959 			

   960 			TExtEtelRequestStatus deleteStoreStatus(phoneBookStr,EMobilePhoneStoreDelete);

   961 			CleanupStack::PushL(deleteStoreStatus);

   962 			phoneBookStr.Delete(deleteStoreStatus,index);

   963 			CHECK_EQUALS_L(WaitForRequestWithTimeOut(deleteStoreStatus, ETimeMedium),KErrNone, 

   964 					_L("RMobilePhoneBookStore::Delete timed-out"));

   965 			CHECK_TRUE_L( ( deleteStoreStatus.Int() == KErrNotFound 

   966 							|| deleteStoreStatus.Int() == KErrNone ),		

   967 						 _L("RMobilePhoneBookStore::Delete returned with an error."));

   968 			index = 2;

   969 			phoneBookStr.Delete(deleteStoreStatus,index);

   970 			CHECK_EQUALS_L(WaitForRequestWithTimeOut(deleteStoreStatus, ETimeMedium),KErrNone, 

   971 					_L("RMobilePhoneBookStore::Delete timed-out"));

   972 			CHECK_TRUE_L( ( deleteStoreStatus.Int() == KErrNotFound 

   973 							|| deleteStoreStatus.Int() == KErrNone ),		

   974 						 _L("RMobilePhoneBookStore::Delete returned with an error."));

   975 			//deleteStoreStatus

   976 			CleanupStack::PopAndDestroy(&deleteStoreStatus);

   977 

   978 			}

   979 		phoneBookStr.GetInfo(phoneStoreInfoStatus, phoneBookInfoPckg);	

   980 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(phoneStoreInfoStatus, ETimeShort), KErrNone, 

   981 			_L("RMobilePhoneBookStore::GetInfo timed-out"));

   982 		CHECK_EQUALS_L(phoneStoreInfoStatus.Int(),  KErrNone,

   983 			 _L("RMobilePhoneBookStore::GetInfo returned with an error"));

   984 		CHECK_TRUE_L(phoneBookInfo.iUsedEntries < phoneBookInfo.iTotalEntries,

   985 			 _L("RMobilePhoneBookStore::GetInfo phonebook is full"));

   986 

   987 		// Ensure RMobilePhoneStore::GetInfo returns iCaps in set of KCapsWriteAccess | KCapsReadAccess 

   988 		TUint32 expectedCaps =  RMobilePhoneStore::KCapsWriteAccess

   989 				| RMobilePhoneStore::KCapsReadAccess;

   990 		CHECK_BITS_SET_L(phoneBookInfo.iCaps, expectedCaps, KNoUnwantedBits,

   991 			_L("RMobilePhoneBookStore::GetInfo returned incorrect caps"));

   992 

   993 

   994 		//1 phoneStoreInfoStatus

   995 		//2 deleteStoreStatus

   996 		CleanupStack::PopAndDestroy(&phoneStoreInfoStatus);

   997 		}

   998 	

   999 	//

  1000 	// SET UP END

  1001 	//

  1002 	

  1003 	StartTest();

  1004 	

  1005 	//

  1006 	// TEST START

  1007 	//

  1008 	TFixedArray<TBuf8<KPBDataClientBuf10>,2> pbData; // Client reserved space for phonebook data

  1009 	TFixedArray<CPhoneBookBuffer*,2> pbBuffer;

  1010 	pbBuffer[0] = new(ELeave) CPhoneBookBuffer(); // used to write phonebook data

  1011 	CleanupStack::PushL(pbBuffer[0]);

  1012 	pbBuffer[0]->Set(&pbData[0]); // Set it to point to the Client buffer

  1013 	pbBuffer[1] = new(ELeave) CPhoneBookBuffer(); // used to write phonebook data

  1014 	CleanupStack::PushL(pbBuffer[1]);

  1015 	pbBuffer[1]->Set(&pbData[1]); // Set it to point to the Client buffer

  1016 

  1017 	// Get all the subsessions for all supported phone books. ADN, SDN etc. 

  1018 	_LIT(KTel,"123456%03d");

  1019 	_LIT(KText,"TelNo %03d");	

  1020 	TFixedArray<TBuf<KBufSize>,noOfPhoneBooks> names;

  1021 	TFixedArray<TBuf<KBufSize>,noOfPhoneBooks> numbers;

  1022 	TInt index[noOfPhoneBooks];

  1023 	TFixedArray<TExtEtelRequestStatus*,noOfPhoneBooks> phoneBookWriteStatus;

  1024 	TExtEtelRequestStatus pbWriteStatus1(*phoneBookStore[0], EMobilePhoneBookStoreWrite);

  1025 	CleanupStack::PushL(pbWriteStatus1);

  1026 	phoneBookWriteStatus[0] = &pbWriteStatus1;

  1027 	TExtEtelRequestStatus pbWriteStatus2(*phoneBookStore[1], EMobilePhoneBookStoreWrite);

  1028 	CleanupStack::PushL(pbWriteStatus2);

  1029 	phoneBookWriteStatus[1] = &pbWriteStatus2;

  1030 

  1031 	

  1032 	// Write a single entry to each phone book using RMobilePhoneBookStore::Write 

  1033 	for(TInt i = 0; i< noOfPhoneBooks; ++i)

  1034 		{

  1035 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

  1036 		numbers[i].Format(KTel,i);

  1037 		names[i].Format(KText,i);

  1038 		TBool ret = EncodeTLVFormat(pbBuffer[i], numbers[i], (TUint8)RMobilePhone::EUnknownNumber

  1039 				, names[i]);

  1040 		CHECK_TRUE_L(ret,_L("EncodeTLVFormat failed"));

  1041 		index[i]=-1;

  1042 		phoneBookStore[i]->Write(*phoneBookWriteStatus[i], pbData[i], index[i]);

  1043 

  1044 		}

  1045 	

  1046 	for(TInt i = 0; i< noOfPhoneBooks; ++i)

  1047 		{

  1048 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

  1049 		// Wait for each request to complete for each of the TExtEtelRequestStatus's used in the write operation.

  1050 		ASSERT_EQUALS(WaitForRequestWithTimeOut(*phoneBookWriteStatus[i]

  1051   				, ETimeMedium), KErrNone,

  1052   				_L("RMobilePhoneBookStore::Write timed-out"));

  1053 		// Check KErrNone is returned for each phone book

  1054   		ASSERT_EQUALS(phoneBookWriteStatus[i]->Int(), KErrNone, 

  1055   					_L("RMobilePhoneBookStore::Write returned with an error"));

  1056 		}

  1057 

  1058 	// Read the written entry from each phone book using RMobilePhoneBookStore::Read 	

  1059 	TFixedArray<TExtEtelRequestStatus*,noOfPhoneBooks> phoneBookReadStatus;

  1060 	TExtEtelRequestStatus pbReadStatus1(*phoneBookStore[0], EMobilePhoneBookStoreRead);

  1061 	CleanupStack::PushL(pbReadStatus1);

  1062 	phoneBookReadStatus[0] = &pbReadStatus1;

  1063 	TExtEtelRequestStatus pbReadStatus2(*phoneBookStore[1], EMobilePhoneBookStoreRead);

  1064 	CleanupStack::PushL(pbReadStatus2);

  1065 	phoneBookReadStatus[1] = &pbReadStatus2;

  1066 	

  1067 	for(TInt i = 0; i < noOfPhoneBooks; ++i)

  1068 		{

  1069 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

  1070 		pbData[i].FillZ();

  1071 		pbData[i].Zero();

  1072 		phoneBookStore[i]->Read(*phoneBookReadStatus[i], index[i], 1, pbData[i]);

  1073 		}

  1074 	

  1075 	for(TInt i = 0; i< noOfPhoneBooks; ++i)

  1076 		{

  1077 		DEBUG_PRINTF2(_L("loop iteration : %d"),i);

  1078 		// Wait for each request to complete for each of the TExtEtelRequestStatus's used in the read operation. 	

  1079 		ASSERT_EQUALS(WaitForRequestWithTimeOut(*phoneBookReadStatus[i]

  1080             				, ETimeMedium), KErrNone,

  1081             				_L("RMobilePhoneBookStore::Read timed-out"));

  1082 		// Check KErrNone is returned for each phone book		

  1083         ASSERT_EQUALS(phoneBookReadStatus[i]->Int(), KErrNone, 

  1084         		_L("RMobilePhoneBookStore::Read returned with an error"));		

  1085 		}

  1086 

  1087 	//

  1088 	// TEST END

  1089 	//

  1090 

  1091     StartCleanup();

  1092 

  1093 	// 1 pbBuffer[0]

  1094 	// 2 pbBuffer[1]

  1095     // 3 pbWriteStatus1

  1096     // 4 pbWriteStatus2

  1097     // 5 pbReadStatus1

  1098     // 6 pbReadStatus2

  1099     for(TInt i = 0; i< noOfPhoneBooks; ++i)

  1100 		{

  1101 		phoneBookWriteStatus[i] = NULL;

  1102 		phoneBookReadStatus[i] = NULL;

  1103 		}

  1104     CleanupStack::PopAndDestroy(6,pbBuffer[0]);	

  1105 	}

  1106 

  1107 

  1108 

  1109 CCTSYIntegrationTestPhoneBookStore0006Base::CCTSYIntegrationTestPhoneBookStore0006Base(CEtelSessionMgr& aEtelSessionMgr)

  1110 	: CCTSYIntegrationTestPhoneBookStoreBase(aEtelSessionMgr)

  1111 /**

  1112  * Constructor.

  1113  */

  1114 	{

  1115 	

  1116 	}

  1117 

  1118 CCTSYIntegrationTestPhoneBookStore0006Base::~CCTSYIntegrationTestPhoneBookStore0006Base()

  1119 /**

  1120  * Destructor.

  1121  */

  1122 	{

  1123 	}

  1124 

  1125 void CCTSYIntegrationTestPhoneBookStore0006Base::DoTestProcedureL(TPhoneBookStoreId aPhoneBookId)

  1126 /**

  1127  * @SYMTestCaseDesc: Read with no SIM present.

  1128  * @SYMTestExpectedResults: Pass - Read request returns KErrEtelInitialisationFailure due to lack of SIM.

  1129  * Reason for test: Verfiy KErrEtelInitialisationFailure is returned.

  1130  */

  1131 	{

  1132 

  1133 	//

  1134 	// SET UP