1 // Copyright (c) 2001-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 //

    15 

    16 #include <e32math.h>

    17 #include <e32test.h>

    18 #include <cntdb.h>

    19 #include <cntitem.h>

    20 #include <cntfldst.h>

    21 #include <cntfield.h>

    22 #include "t_utils2.h"

    23 #include <cntview.h>

    24 #include <cntviewbase.h>

    25 #include <coreappstest/testserver.h>

    26 //

    27 // Constants.

    28 //

    29 

    30 _LIT(KNewLine,"\n");

    31 _LIT(KBackSpace,"\x08");

    32 _LIT(KVisualCounterFormat,"%S%d");

    33 _LIT8(KUnicodeStartFile,"\xFF\xFE");

    34 _LIT8(KUnicodeLineEnd,"\x0D\x00\x0a\x00");

    35 const TInt KMaxLogLength=0x100;

    36 

    37 

    38 

    39 

    40 //

    41 // CLog.

    42 //

    43 

    44 CLog* CLog::NewL(RTest& aTest,const TDesC& aLogFileName)

    45 	{

    46 	CLog* self=new(ELeave) CLog(aTest,aLogFileName);

    47 	CleanupStack::PushL(self);

    48 	self->ConstructL();

    49 	CleanupStack::Pop(); // self.

    50 	return self;

    51 	}

    52 

    53 CLog::CLog(RTest& aTest,const TDesC& aLogFileName)

    54 	: iTest(aTest),iLogFileName(aLogFileName),iVisualCounter(-1)

    55 	{

    56 	}

    57 

    58 CLog::~CLog()

    59 	{

    60 	iLogFile.Close();

    61 	delete iFileRegister;

    62 	}

    63 

    64 void CLog::ConstructL()

    65 	{

    66 	iFileRegister = CTestRegister::NewLC();

    67 	CleanupStack::Pop(iFileRegister);

    68 	

    69 	iFileRegister->CreateLogFileLC(iLogFile, iLogFileName);

    70 	User::LeaveIfError(iLogFile.Write(KUnicodeStartFile));

    71 	CleanupStack::Pop(&iLogFile); // This file stays open

    72 	}

    73 

    74 void CLog::Log(TRefByValue<const TDesC> aFmt,...)

    75 	{

    76 	VA_LIST list;

    77 	VA_START(list,aFmt);

    78 	TBuf<KMaxLogLength> buf;

    79 	buf.FormatList(aFmt,list);

    80 

    81 	iLogFile.Write(TPtrC8((TUint8 *)buf.Ptr(),buf.Size()));

    82 	iLogFile.Flush();

    83 	iTest.Printf(buf);

    84 	}

    85 

    86 void CLog::LogLine(TRefByValue<const TDesC> aFmt,...)

    87 	{

    88 	VA_LIST list;

    89 	VA_START(list,aFmt);

    90 	TBuf<KMaxLogLength> buf;

    91 	buf.FormatList(aFmt,list);

    92 

    93 	iLogFile.Write(TPtrC8((TUint8 *)buf.Ptr(),buf.Size()));

    94 	iLogFile.Write(KUnicodeLineEnd);

    95 	iLogFile.Flush();

    96 	buf.Append(KNewLine);

    97 	iTest.Printf(buf);

    98 	}

    99 

   100 void CLog::LogLineNoEcho(TRefByValue<const TDesC> aFmt,...)

   101 	{

   102 	VA_LIST list;

   103 	VA_START(list,aFmt);

   104 	TBuf<KMaxLogLength> buf;

   105 	buf.FormatList(aFmt,list);

   106 

   107 	iLogFile.Write(TPtrC8((TUint8 *)buf.Ptr(),buf.Size()));

   108 	iLogFile.Write(KUnicodeLineEnd);

   109 	iLogFile.Flush();

   110 	}

   111 

   112 void CLog::WriteLogToCommPortL()

   113 	{

   114 	iLogFile.Close();

   115 	iFileRegister->OpenLogFileLC(iLogFile, iLogFileName);

   116 	CleanupStack::Pop(&iLogFile);

   117 	TInt pos=2;

   118 	iLogFile.Seek(ESeekStart,pos); // Ignore Unicode header.

   119 	TBuf<KMaxLogLength> line;

   120 	while (ReadLogLineL(line))

   121 		{

   122 		RDebug::Print(line);

   123 		}

   124 	}

   125 

   126 TBool CLog::ReadLogLineL(TDes& aLine)

   127 	{

   128 	TBuf8<2> character=_L8("  ");

   129 	TBuf8<4> lineEndTestBuf=_L8("    ");

   130 

   131 	aLine.SetLength(0);

   132 	while (lineEndTestBuf!=KUnicodeLineEnd)

   133 		{

   134 		User::LeaveIfError(iLogFile.Read(character,2));

   135 		if (character.Length()>0)

   136 			{

   137 			lineEndTestBuf[0]=lineEndTestBuf[2];

   138 			lineEndTestBuf[1]=lineEndTestBuf[3];

   139 			lineEndTestBuf[2]=character[0];

   140 			lineEndTestBuf[3]=character[1];

   141 

   142 			const TPtrC16 widePtr((TUint16*)character.Ptr(),1);

   143 			aLine.Append(widePtr);

   144 			}

   145 		else

   146 			{

   147 			return EFalse;

   148 			}

   149 		}

   150 

   151 	aLine=aLine.Left(aLine.Length()-2); // Strip off \n\r.

   152 	return ETrue;

   153 	}

   154 

   155 void CLog::IncVisualCounter()

   156 	{

   157 	TBuf<8> backSpaceBuf;

   158 

   159 	if (iVisualCounter>=0)

   160 		{

   161 		TInt numDigits=1;

   162 		TInt divisor=10;

   163 

   164 		FOREVER

   165 			{

   166 			if (iVisualCounter/divisor>0)

   167 				{

   168 				divisor*=10;

   169 				++numDigits;

   170 				}

   171 			else

   172 				{

   173 				break;

   174 				}

   175 			}

   176 

   177 		for (TInt ii=0;ii<numDigits;++ii)

   178 			{

   179 			backSpaceBuf.Append(KBackSpace);

   180 			}

   181 		}

   182 

   183 	iTest.Printf(KVisualCounterFormat,&backSpaceBuf,++iVisualCounter);

   184 	}

   185 

   186 void CLog::EndVisualCounter()

   187 	{

   188 	iTest.Printf(KNewLine);

   189 	iVisualCounter=-1;

   190 	}

   191 

   192 

   193 

   194 

   195 //

   196 // CRandomContactGenerator.

   197 //

   198 

   199 CRandomContactGenerator::CRandomContactGenerator()

   200 	{

   201 	}

   202 

   203 CRandomContactGenerator::CRandomContactGenerator(MRandomWordGenerator* aFirstname, MRandomWordGenerator* aLastname, MRandomWordGenerator* aCompany ) :

   204 	iFirstName(aFirstname)

   205 	{

   206 	if(aLastname)

   207 		{

   208 		iLastName = aLastname;

   209 		}

   210 	else

   211 		{

   212 		iLastName = iFirstName;

   213 		}

   214 	if(aCompany)

   215 		{

   216 		iCoName = aCompany;

   217 		}

   218 	else

   219 		{

   220 		iCoName = iLastName;

   221 		}

   222 	}

   223 

   224 CRandomContactGenerator::~CRandomContactGenerator()

   225 	{

   226 	delete iTemplate;

   227 	delete iFirstName;

   228 	if (iLastName != iFirstName)

   229 		delete iLastName;

   230 	if (iCoName != iFirstName && iCoName != iLastName)

   231 		delete iCoName;

   232 	}

   233 

   234 CRandomContactGenerator* CRandomContactGenerator::NewL()

   235 	{

   236 	CRandomContactGenerator* self=new(ELeave) CRandomContactGenerator();

   237 	CleanupStack::PushL(self);

   238 	//self->ConstructL();

   239 	CleanupStack::Pop(); // self.

   240 	return self;

   241 	}

   242 

   243 /** Takes ownership of the args. If this Leaves the args will be deleted. Args can be duplicates

   244 	If aCompany is NULL, this uses aLastname to generate company names. 

   245 	If aLastname is NULL, this uses aFirstname to generate last names (and, potentially, company names as well) */

   246 CRandomContactGenerator* CRandomContactGenerator::NewL(MRandomWordGenerator* aFirstname, MRandomWordGenerator* aLastname, MRandomWordGenerator* aCompany )

   247 	{

   248 	CRandomContactGenerator* self=new(ELeave) CRandomContactGenerator(aFirstname, aLastname, aCompany);

   249 	CleanupStack::PushL(self);

   250 	self->ConstructL();

   251 	CleanupStack::Pop(); // self.

   252 	return self;

   253 	}

   254 

   255 void CRandomContactGenerator::ConstructL()

   256 	{}

   257 

   258 

   259 void CRandomContactGenerator::SetDbL(CContactDatabase& aDb)

   260 	{

   261 	iDb=&aDb;

   262 	iTemplate=STATIC_CAST(CContactTemplate*,iDb->ReadContactL(iDb->TemplateId()));

   263 	}

   264 

   265 TPtrC CRandomContactGenerator::PhoneMatch() const

   266 	{

   267 	return TPtrC(iPhoneMatch);

   268 	}

   269 

   270 TPtrC CRandomContactGenerator::NameMatch() const

   271 	{

   272 	return TPtrC(iNameMatch);

   273 	}

   274 

   275 TPtrC CRandomContactGenerator::EmailMatch() const

   276 	{

   277 	return TPtrC(iEmailMatch);

   278 	}

   279 	

   280 void CRandomContactGenerator::SetRandomWordL(TDes& aBuf, TInt32 aType )

   281 	{

   282 	MRandomWordGenerator* word = iFirstName;

   283 	TInt len = 16;

   284 	switch (aType)

   285 		{

   286 		case KUidContactFieldFamilyNameValue:

   287 		case KUidContactFieldFamilyNamePronunciationValue:

   288 			word = iLastName;

   289 			break;

   290 		case KUidContactFieldCompanyNameValue:

   291 		case KUidContactFieldCompanyNamePronunciationValue:

   292 			word = iCoName;

   293 			break;

   294 		case KUidContactFieldEMailValue:

   295 			len = 32;

   296 			break;

   297 		}

   298 	if(!word)

   299 		{

   300 		SetRandomAlphaString(aBuf,len);

   301 		return;

   302 		}

   303 	aBuf = *word->WordLC();

   304 	CleanupStack::PopAndDestroy();

   305 	

   306 	// the following are to make these look a bite more realistic

   307 	if(aType==KUidContactFieldEMailValue)	

   308 		{

   309 		aBuf.Append('@');

   310 		aBuf.Append(*word->WordLC());

   311 		CleanupStack::PopAndDestroy();

   312 		aBuf.Append(_L(".co.uk"));

   313 		}

   314 	if((aType==KUidContactFieldCompanyNameValue || aType==KUidContactFieldCompanyNamePronunciationValue) 

   315 			&& word==iLastName)

   316 		{

   317 		aBuf.Append(' ');

   318 		aBuf.Append(*word->WordLC());

   319 		CleanupStack::PopAndDestroy();

   320 		aBuf.Append(_L(" Ltd."));

   321 		}

   322 	}

   323 

   324 TContactItemId CRandomContactGenerator::AddTypicalRandomContactL()

   325 	{

   326 	CTestContact* contact=CTestContact::NewLC(*iTemplate);

   327 	HBufC* buf=HBufC::NewLC(64);

   328 	TPtr bufPtr=buf->Des();

   329 	SetRandomWordL(bufPtr,KUidContactFieldGivenNameValue);

   330 	contact->SetFirstNameL(bufPtr);

   331 	iNameMatch=bufPtr;

   332 	SetRandomWordL(bufPtr,KUidContactFieldFamilyNameValue);

   333 	contact->SetLastNameL(bufPtr);

   334 	SetRandomWordL(bufPtr,KUidContactFieldCompanyNameValue);

   335 	contact->SetCompanyNameL(bufPtr);

   336 	SetRandomNumericString(bufPtr,16);

   337 	contact->SetWorkPhoneL(bufPtr);

   338 	iPhoneMatch=bufPtr;

   339 	SetRandomNumericString(bufPtr,16);

   340 	contact->SetWorkMobileL(bufPtr);

   341 	SetRandomNumericString(bufPtr,16);

   342 	contact->SetHomePhoneL(bufPtr);

   343 	SetRandomWordL(bufPtr,KUidContactFieldEMailValue);

   344 	contact->SetWorkEmailAddressL(bufPtr);

   345 	iEmailMatch=bufPtr;

   346 

   347 	TContactItemId id = iDb->AddNewContactL(contact->ContactItem());

   348 	CleanupStack::PopAndDestroy(2); // buf, contact.

   349 	return id;

   350 	}

   351 

   352 TContactItemId CRandomContactGenerator::AddTypicalRandomContactWithNamesL(const RArray<TInt>& iNames, TBool aWithMapping)

   353 	{

   354 	CTestContact* contact=CTestContact::NewLC(*iTemplate);

   355 	HBufC* buf=HBufC::NewLC(64);

   356 	TPtr bufPtr=buf->Des();

   357 	TInt i;

   358 	for(i=iNames.Count()-1;i>=0;i--) 

   359 		{

   360 		SetRandomWordL(bufPtr,iNames[i]);

   361 		if(!aWithMapping )

   362 			{

   363 			contact->SetTextFieldL(TUid::Uid(iNames[i]),bufPtr);

   364 			}

   365 		else

   366 			{

   367 			switch (iNames[i])

   368 				{

   369 				case KUidContactFieldCompanyNameValue: 

   370 					contact->SetCompanyNameL(bufPtr);

   371 					break;

   372 				case KUidContactFieldCompanyNamePronunciationValue:

   373 					contact->SetCompanyNameL(bufPtr, ETrue);

   374 					break;

   375 				case KUidContactFieldGivenNameValue:

   376 					contact->SetFirstNameL(bufPtr);

   377 					break;

   378 				case KUidContactFieldGivenNamePronunciationValue:

   379 					contact->SetFirstNameL(bufPtr, ETrue);

   380 					break;

   381 				case KUidContactFieldFamilyNameValue:

   382 					contact->SetLastNameL(bufPtr);

   383 					break;

   384 				case KUidContactFieldFamilyNamePronunciationValue:

   385 					contact->SetLastNameL(bufPtr, ETrue);

   386 					break;

   387 				default:

   388 					contact->SetTextFieldL(TUid::Uid(iNames[i]),bufPtr);

   389 				}

   390 			}

   391 		iNameMatch=bufPtr;

   392 	}

   393 	

   394 	SetRandomNumericString(bufPtr,16);

   395 	contact->SetWorkPhoneL(bufPtr);

   396 	iPhoneMatch=bufPtr;

   397 	SetRandomNumericString(bufPtr,16);

   398 	contact->SetWorkMobileL(bufPtr);

   399 	SetRandomNumericString(bufPtr,16);

   400 	contact->SetHomePhoneL(bufPtr);

   401 	SetRandomWordL(bufPtr,KUidContactFieldEMailValue);

   402 	contact->SetWorkEmailAddressL(bufPtr);

   403 	iEmailMatch=bufPtr;

   404 

   405 	TContactItemId id = iDb->AddNewContactL(contact->ContactItem());

   406 	CleanupStack::PopAndDestroy(2); // buf, contact.

   407 	return id;

   408 	}

   409 

   410 void CRandomContactGenerator::AddAtypicalRandomContactL()

   411 	{

   412 	CTestContact* contact=CTestContact::NewLC(*iTemplate);

   413 	HBufC* buf=HBufC::NewLC(256);

   414 	TPtr bufPtr=buf->Des();

   415 	SetRandomAlphaString(bufPtr,32);

   416 	contact->SetFirstNameL(bufPtr);

   417 	SetRandomAlphaString(bufPtr,32);

   418 	contact->SetLastNameL(bufPtr);

   419 	SetRandomAlphaString(bufPtr,32);

   420 	contact->SetCompanyNameL(bufPtr);

   421 	SetRandomAlphaString(bufPtr,32);

   422 	contact->SetJobTitleL(bufPtr);

   423 	SetRandomNumericString(bufPtr,24);

   424 	contact->SetWorkPhoneL(bufPtr);

   425 	SetRandomNumericString(bufPtr,24);

   426 	contact->SetWorkMobileL(bufPtr);

   427 	SetRandomNumericString(bufPtr,24);

   428 	contact->SetHomePhoneL(bufPtr);

   429 	SetRandomNumericString(bufPtr,24);

   430 	contact->SetHomeMobileL(bufPtr);

   431 	SetRandomNumericString(bufPtr,24);

   432 	contact->SetFaxL(bufPtr);

   433 	SetRandomAlphaNumericString(bufPtr,48);

   434 	contact->SetWorkEmailAddressL(bufPtr);

   435 	SetRandomAlphaNumericString(bufPtr,48);

   436 	contact->SetInternetAddressL(bufPtr);

   437 	SetRandomAlphaNumericString(bufPtr,32);

   438 	contact->SetStreetL(bufPtr);

   439 	SetRandomAlphaString(bufPtr,32);

   440 	contact->SetTownL(bufPtr);

   441 	SetRandomAlphaString(bufPtr,32);

   442 	contact->SetCountyL(bufPtr);

   443 	SetRandomAlphaNumericString(bufPtr,16);

   444 	contact->SetPostCodeL(bufPtr);

   445 	SetRandomAlphaString(bufPtr,32);

   446 	contact->SetCountryL(bufPtr);

   447 	SetRandomAlphaNumericString(bufPtr,256);

   448 	contact->SetNotesL(bufPtr);

   449 

   450 	iDb->AddNewContactL(contact->ContactItem());

   451 	CleanupStack::PopAndDestroy(2); // buf, contact.

   452 	}

   453 

   454 TContactItemId CRandomContactGenerator::AddTypicalContactForFilterL(TInt aBitWiseFilter, TInt& aLeaveCode)

   455 	{

   456 	TContactItemId retval = 0;

   457 	CTestContact* contact=CTestContact::NewLC(*iTemplate);

   458 	HBufC* buf=HBufC::NewLC(32);

   459 	TPtr bufPtr=buf->Des();

   460 	SetRandomAlphaString(bufPtr,16);

   461 	contact->SetFirstNameL(bufPtr);

   462 	SetRandomAlphaString(bufPtr,16);

   463 	contact->SetLastNameL(bufPtr);

   464 	SetRandomAlphaString(bufPtr,16);

   465 	contact->SetCompanyNameL(bufPtr);

   466 

   467 	if(aBitWiseFilter&CContactDatabase::ELandLine)

   468 		{

   469 		SetRandomNumericString(bufPtr,16);

   470 		contact->SetWorkPhoneL(bufPtr);

   471 		}

   472 	if(aBitWiseFilter&CContactDatabase::ESmsable)

   473 		{

   474 		SetRandomNumericString(bufPtr,16);

   475 		contact->SetWorkMobileL(bufPtr);

   476 		}

   477 	if(aBitWiseFilter&CContactDatabase::EMailable)

   478 		{

   479 		SetRandomAlphaNumericString(bufPtr,32);

   480 		if (aBitWiseFilter&CContactDatabase::EHome)

   481 			contact->SetHomeEmailAddressL(bufPtr);

   482 		else

   483 			contact->SetWorkEmailAddressL(bufPtr);

   484 		}

   485 	if(aBitWiseFilter&CContactDatabase::EFaxable)

   486 		{

   487 		SetRandomNumericString(bufPtr,16);

   488 		contact->SetFaxL(bufPtr);

   489 		}

   490 

   491 

   492 	TRAP( aLeaveCode, { retval = iDb->AddNewContactL(contact->ContactItem()); } );

   493 	CleanupStack::PopAndDestroy(2); // buf, contact.

   494 	return retval;

   495 	}

   496 

   497 TContactItemId CRandomContactGenerator::AddTypicalContactForFilterL(TInt aBitWiseFilter)

   498 	{

   499 	TUid fakeUid = TUid::Null();

   500 	return AddTypicalContactForFilterL(aBitWiseFilter, fakeUid);

   501 	}

   502 	

   503 TContactItemId CRandomContactGenerator::AddTypicalContactForFilterL(TInt aBitWiseFilter, TUid aIMProtocol)

   504 	{

   505 	CTestContact* contact=CTestContact::NewLC(*iTemplate);

   506 	HBufC* buf=HBufC::NewLC(32);

   507 	TPtr bufPtr=buf->Des();

   508 	SetRandomAlphaString(bufPtr,16);

   509 	contact->SetFirstNameL(bufPtr);

   510 	SetRandomAlphaString(bufPtr,16);

   511 	contact->SetLastNameL(bufPtr);

   512 	SetRandomAlphaString(bufPtr,16);

   513 	contact->SetCompanyNameL(bufPtr);

   514 

   515 	if(aBitWiseFilter&CContactDatabase::ELandLine)

   516 		{

   517 		SetRandomNumericString(bufPtr,16);

   518 		contact->SetWorkPhoneL(bufPtr);

   519 		}

   520 	if(aBitWiseFilter&CContactDatabase::ESmsable)

   521 		{

   522 		SetRandomNumericString(bufPtr,16);

   523 		contact->SetWorkMobileL(bufPtr);

   524 		}

   525 	if(aBitWiseFilter&CContactDatabase::EMailable)

   526 		{

   527 		SetRandomAlphaNumericString(bufPtr,32);

   528 		if (aBitWiseFilter&CContactDatabase::EHome)

   529 			contact->SetHomeEmailAddressL(bufPtr);

   530 		else

   531 			contact->SetWorkEmailAddressL(bufPtr);

   532 		}

   533 	if(aBitWiseFilter&CContactDatabase::EFaxable)

   534 		{

   535 		SetRandomNumericString(bufPtr,16);

   536 		contact->SetFaxL(bufPtr);

   537 		}

   538 

   539 	if(aBitWiseFilter&CContactDatabase::ERingTone)

   540 		{

   541 		SetRandomNumericString(bufPtr,16);

   542 		contact->SetRingToneL(bufPtr);

   543 		}

   544 	if(aBitWiseFilter&CContactDatabase::EVoiceDial)

   545 		{

   546 		SetRandomNumericString(bufPtr,16);

   547 		contact->SetVoiceDialL(bufPtr);

   548 		}

   549 

   550 	if(aBitWiseFilter&CContactDatabase::EWirelessVillage)

   551 		{

   552 		SetRandomNumericString(bufPtr,16);

   553 		contact->SetIMAddressL(bufPtr, aIMProtocol);

   554 		}		

   555 

   556 	TContactItemId id = iDb->AddNewContactL(contact->ContactItem());

   557 	CleanupStack::PopAndDestroy(2); // buf, contact.

   558 	return id;

   559 	}

   560 	

   561 

   562 TContactItemId CRandomContactGenerator::AddTypicalContactForLocalViewPreferencesL(TContactViewPreferences aContactTypes)

   563 	{

   564 	CTestContact* contact=CTestContact::NewLC(*iTemplate);

   565 	HBufC* buf=HBufC::NewLC(32);

   566 	TPtr bufPtr=buf->Des();

   567 				

   568 	if(aContactTypes&EUnSortedAtBeginning || aContactTypes&EUnSortedAtEnd)

   569 		{

   570 		SetRandomNumericString(bufPtr,16);

   571 		contact->SetWorkPhoneL(bufPtr);

   572 		}

   573 

   574 	if(aContactTypes&ESingleWhiteSpaceIsEmptyField)

   575 		{

   576 		contact->SetFirstNameL(_L(" "));

   577 		contact->SetCompanyNameL(_L(" "));

   578 

   579 		SetRandomAlphaString(bufPtr,16);

   580 		contact->SetLastNameL(bufPtr);

   581 

   582 		SetRandomNumericString(bufPtr,16);

   583 		contact->SetWorkPhoneL(bufPtr);

   584 		}

   585 

   586 

   587 	TContactItemId newId = iDb->AddNewContactL(contact->ContactItem());

   588 	CleanupStack::PopAndDestroy(2); // buf, contact.

   589 	return newId;

   590 	}

   591 

   592 void CRandomContactGenerator::SetRandomAlphaString(TDes& aBuf,TInt aLength)

   593 	{

   594 	aBuf.SetLength(aLength);

   595 

   596 	for (TInt ii=0;ii<aLength;++ii)

   597 		{

   598 		aBuf[ii]=RandomAlphaCharCode();

   599 		}

   600 	}

   601 

   602 void CRandomContactGenerator::SetRandomNumericString(TDes& aBuf,TInt aLength)

   603 	{

   604 	aBuf.SetLength(aLength);

   605 

   606 	for (TInt ii=0;ii<aLength;++ii)

   607 		{

   608 		aBuf[ii]=RandomNumericCharCode();

   609 		}

   610 	}

   611 

   612 void CRandomContactGenerator::SetRandomAlphaNumericString(TDes& aBuf,TInt aLength)

   613 	{

   614 	aBuf.SetLength(aLength);

   615 

   616 	for (TInt ii=0;ii<aLength;++ii)

   617 		{

   618 		aBuf[ii]=RandomAlphaNumbericCharCode();

   619 		}

   620 	}

   621 

   622 TText CRandomContactGenerator::RandomAlphaCharCode()

   623 	{

   624 	return RandomCharCode('A','z',' ');

   625 	}

   626 

   627 TText CRandomContactGenerator::RandomNumericCharCode()

   628 	{

   629 	return RandomCharCode('0','9',' ');

   630 	}

   631 

   632 TText CRandomContactGenerator::RandomAlphaNumbericCharCode()

   633 	{

   634 	return RandomCharCode('0','z',' ');

   635 	}

   636 

   637 TText CRandomContactGenerator::RandomCharCode(TText aLowerBound,TText aUpperBound,TText aException)

   638 	{

   639 	TText charCode=0;

   640 	

   641 	do

   642 		{

   643 		charCode=RandomCharCode(aLowerBound,aUpperBound);

   644 		}

   645 		while (charCode==aException);

   646 

   647 	return charCode;

   648 	}

   649 

   650 TText CRandomContactGenerator::RandomCharCode(TText aLowerBound,TText aUpperBound)

   651 	{

   652 	TText charCode=STATIC_CAST(TText,(Math::Rand(iRandSeed)%(aUpperBound-aLowerBound))+aLowerBound);

   653 	ASSERT(charCode>=aLowerBound && charCode<=aUpperBound);

   654 	return charCode;

   655 	}

   656 

   657 

   658 //

   659 // CContactNameGenerator.

   660 //

   661 /*

   662 CContactNameGenerator* CContactNameGenerator::NewL(RTest& aTest,CLog& aLog)

   663 	{

   664 	CContactNameGenerator* self=new(ELeave) CContactNameGenerator(aTest,aLog);

   665 	CleanupStack::PushL(self);

   666 	self->ConstructL();

   667 	CleanupStack::Pop(); // self.

   668 	return self;

   669 	}

   670 

   671 CContactNameGenerator::CContactNameGenerator(RTest& aTest,CLog& aLog)

   672 	: iTest(aTest),iLog(aLog)

   673 	{

   674 	}

   675 

   676 CContactNameGenerator::~CContactNameGenerator()

   677 	{

   678 	}

   679 

   680 void CContactNameGenerator::ConstructL()

   681 	{

   682 	}

   683 

   684 void CContactNameGenerator::SetDbL(CContactDatabase& aDb)

   685 	{

   686 	iDb=&aDb;

   687 	iTemplate=STATIC_CAST(CContactTemplate*,iDb->ReadContactL(iDb->TemplateId()));

   688 	}

   689 */

   690 

   691 //

   692 // CTestContact.

   693 //

   694 

   695 CTestContact* CTestContact::NewL(CContactItem& aSeedContact)

   696 	{

   697 	CTestContact* self=CTestContact::NewLC(aSeedContact);

   698 	CleanupStack::Pop();

   699 	return self;

   700 	}

   701 

   702 CTestContact* CTestContact::NewLC(CContactItem& aSeedContact)

   703 	{

   704 	CTestContact* self=new(ELeave) CTestContact();

   705 	CleanupStack::PushL(self);

   706 	self->ConstructL(aSeedContact);

   707 	return self;

   708 	}

   709 

   710 CTestContact::CTestContact()

   711 	{

   712 	}

   713 

   714 void CTestContact::ConstructL(CContactItem& aSeedContact)

   715 	{

   716 	iContactItem=CContactCard::NewL(&aSeedContact);

   717 	}

   718 

   719 CTestContact::~CTestContact()

   720 	{

   721 	delete iContactItem;

   722 	}

   723 

   724 CContactItem& CTestContact::ContactItem()

   725 	{

   726 	return *iContactItem;

   727 	}

   728 

   729 const TPtrC CTestContact::FirstNameL()

   730 	{

   731 	return TextFieldL(KUidContactFieldGivenName);

   732 	}

   733 

   734 const TPtrC CTestContact::LastNameL()

   735 	{

   736 	return TextFieldL(KUidContactFieldFamilyName);

   737 	}

   738 

   739 const TPtrC CTestContact::CompanyNameL()

   740 	{

   741 	return TextFieldL(KUidContactFieldCompanyName);

   742 	}

   743 

   744 const TPtrC CTestContact::JobTitleL()

   745 	{

   746 	return TextFieldL(KUidContactFieldJobTitle);

   747 	}

   748 

   749 const TPtrC CTestContact::WorkPhoneL()

   750 	{

   751 	CContentType* contentType=CContentType::NewL();

   752 	CleanupStack::PushL(contentType);

   753 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   754 	contentType->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   755 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   756 	const TPtrC text=TextFieldL(*contentType);

   757 	CleanupStack::PopAndDestroy(); // contentType.

   758 	return text;

   759 	}

   760 

   761 const TPtrC CTestContact::WorkMobileL()

   762 	{

   763 	CContentType* contentType=CContentType::NewL();

   764 	CleanupStack::PushL(contentType);

   765 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   766 	contentType->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   767 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   768 	contentType->AddFieldTypeL(KUidContactFieldVCardMapCELL);

   769 	const TPtrC text=TextFieldL(*contentType);

   770 	CleanupStack::PopAndDestroy(); // contentType.

   771 	return text;

   772 	}

   773 

   774 const TPtrC CTestContact::HomePhoneL()

   775 	{

   776 	CContentType* contentType=CContentType::NewL();

   777 	CleanupStack::PushL(contentType);

   778 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   779 	contentType->AddFieldTypeL(KUidContactFieldVCardMapHOME);

   780 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   781 	const TPtrC text=TextFieldL(*contentType);

   782 	CleanupStack::PopAndDestroy(); // contentType.

   783 	return text;

   784 	}

   785 

   786 const TPtrC CTestContact::HomeMobileL()

   787 	{

   788 	CContentType* contentType=CContentType::NewL();

   789 	CleanupStack::PushL(contentType);

   790 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   791 	contentType->AddFieldTypeL(KUidContactFieldVCardMapHOME);

   792 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   793 	contentType->AddFieldTypeL(KUidContactFieldVCardMapCELL);

   794 	const TPtrC text=TextFieldL(*contentType);

   795 	CleanupStack::PopAndDestroy(); // contentType.

   796 	return text;

   797 	}

   798 

   799 const TPtrC CTestContact::FaxL()

   800 	{

   801 	return TextFieldL(KUidContactFieldFax);

   802 	}

   803 

   804 const TPtrC CTestContact::EmailAddressL()

   805 	{

   806 	return TextFieldL(KUidContactFieldEMail);

   807 	}

   808 

   809 const TPtrC CTestContact::InternetAddressL()

   810 	{

   811 	return TextFieldL(KUidContactFieldUrl);

   812 	}

   813 

   814 const TPtrC CTestContact::StreetL()

   815 	{

   816 	return TextFieldL(KUidContactFieldAddress);

   817 	}

   818 

   819 const TPtrC CTestContact::TownL()

   820 	{

   821 	return TextFieldL(KUidContactFieldLocality);

   822 	}

   823 

   824 const TPtrC CTestContact::CountyL()

   825 	{

   826 	return TextFieldL(KUidContactFieldRegion);

   827 	}

   828 

   829 const TPtrC CTestContact::PostCodeL()

   830 	{

   831 	return TextFieldL(KUidContactFieldPostcode);

   832 	}

   833 

   834 const TPtrC CTestContact::CountryL()

   835 	{

   836 	return TextFieldL(KUidContactFieldCountry);

   837 	}

   838 

   839 const TPtrC CTestContact::NotesL()

   840 	{

   841 	return TextFieldL(KUidContactFieldNote);

   842 	}

   843 

   844 void CTestContact::SetFirstNameL(const TDesC& aFirstName, TBool aIsPronunciation)

   845 	{

   846 	const TUid id = aIsPronunciation ? KUidContactFieldGivenNamePronunciation : KUidContactFieldGivenName;

   847 	SetTextFieldL(id,aFirstName, KUidContactFieldVCardMapUnusedN);

   848 	}

   849 

   850 void CTestContact::SetLastNameL(const TDesC& aLastName, TBool aIsPronunciation)

   851 	{

   852 	const TUid id = aIsPronunciation ? KUidContactFieldFamilyNamePronunciation : KUidContactFieldFamilyName;

   853 	SetTextFieldL(id,aLastName, KUidContactFieldVCardMapUnusedN);

   854 	}

   855 

   856 void CTestContact::SetCompanyNameL(const TDesC& aCompanyName, TBool aIsPronunciation)

   857 	{	

   858 	if ( aIsPronunciation )

   859 		SetTextFieldL(KUidContactFieldCompanyNamePronunciation,aCompanyName, KUidContactFieldVCardMapORGPronunciation);

   860 	else

   861 		SetTextFieldL(KUidContactFieldCompanyName,aCompanyName, KUidContactFieldVCardMapORG);

   862 	}

   863 

   864 void CTestContact::SetJobTitleL(const TDesC& aJobTitle)

   865 	{

   866 	SetTextFieldL(KUidContactFieldJobTitle,aJobTitle);

   867 	}

   868 

   869 void CTestContact::SetWorkPhoneL(const TDesC& aWorkPhone)

   870 	{

   871 	CContentType* contentType=CContentType::NewL();

   872 	CleanupStack::PushL(contentType);

   873 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   874 	contentType->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   875 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   876 	SetTextFieldL(*contentType,aWorkPhone);

   877 	CleanupStack::PopAndDestroy(); // contentType.

   878 	}

   879 

   880 void CTestContact::SetWorkMobileL(const TDesC& aWorkMobile)

   881 	{

   882 	CContentType* contentType=CContentType::NewL();

   883 	CleanupStack::PushL(contentType);

   884 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   885 	contentType->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   886 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   887 	contentType->AddFieldTypeL(KUidContactFieldVCardMapCELL);

   888 	SetTextFieldL(*contentType,aWorkMobile);

   889 	CleanupStack::PopAndDestroy(); // contentType.

   890 	}

   891 

   892 void CTestContact::SetHomePhoneL(const TDesC& aHomePhone)

   893 	{

   894 	CContentType* contentType=CContentType::NewL();

   895 	CleanupStack::PushL(contentType);

   896 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   897 	contentType->AddFieldTypeL(KUidContactFieldVCardMapHOME);

   898 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   899 	SetTextFieldL(*contentType,aHomePhone);

   900 	CleanupStack::PopAndDestroy(); // contentType.

   901 	}

   902 

   903 void CTestContact::SetHomeMobileL(const TDesC& aHomeMobile)

   904 	{

   905 	CContentType* contentType=CContentType::NewL();

   906 	CleanupStack::PushL(contentType);

   907 	contentType->AddFieldTypeL(KUidContactFieldPhoneNumber);

   908 	contentType->AddFieldTypeL(KUidContactFieldVCardMapHOME);

   909 	contentType->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   910 	contentType->AddFieldTypeL(KUidContactFieldVCardMapCELL);

   911 	SetTextFieldL(*contentType,aHomeMobile);

   912 	CleanupStack::PopAndDestroy(); // contentType.

   913 	}

   914 

   915 void CTestContact::SetFaxL(const TDesC& aFax)

   916 	{

   917 	SetTextFieldL(KUidContactFieldFax,aFax);

   918 	}

   919 

   920 void CTestContact::SetHomeEmailAddressL(const TDesC& aEmailAddress)

   921 	{

   922 	CContentType* contentType=CContentType::NewL();

   923 	CleanupStack::PushL(contentType);

   924 	contentType->AddFieldTypeL(KUidContactFieldEMail);

   925 	contentType->AddFieldTypeL(KUidContactFieldVCardMapHOME);

   926 	SetTextFieldL(*contentType,aEmailAddress);

   927 	CleanupStack::PopAndDestroy(contentType);

   928 	}

   929 

   930 void CTestContact::SetWorkEmailAddressL(const TDesC& aEmailAddress)

   931 	{

   932 	CContentType* contentType=CContentType::NewL();

   933 	CleanupStack::PushL(contentType);

   934 	contentType->AddFieldTypeL(KUidContactFieldEMail);

   935 	contentType->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   936 	SetTextFieldL(*contentType,aEmailAddress);

   937 	CleanupStack::PopAndDestroy(contentType); 

   938 	}

   939 

   940 

   941 void CTestContact::SetInternetAddressL(const TDesC& aInternetAddress)

   942 	{

   943 	SetTextFieldL(KUidContactFieldUrl,aInternetAddress);

   944 	}

   945 

   946 void CTestContact::SetStreetL(const TDesC& aStreet)

   947 	{

   948 	SetTextFieldL(KUidContactFieldAddress,aStreet);

   949 	}

   950 

   951 void CTestContact::SetTownL(const TDesC& aTown)

   952 	{

   953 	SetTextFieldL(KUidContactFieldLocality,aTown);

   954 	}

   955 

   956 void CTestContact::SetCountyL(const TDesC& aCounty)

   957 	{

   958 	SetTextFieldL(KUidContactFieldRegion,aCounty);

   959 	}

   960 

   961 void CTestContact::SetPostCodeL(const TDesC& aPostCode)

   962 	{

   963 	SetTextFieldL(KUidContactFieldPostcode,aPostCode);

   964 	}

   965 

   966 void CTestContact::SetCountryL(const TDesC& aCountry)

   967 	{

   968 	SetTextFieldL(KUidContactFieldCountry,aCountry);

   969 	}

   970 

   971 void CTestContact::SetNotesL(const TDesC& aNotes)

   972 	{

   973 	SetTextFieldL(KUidContactFieldNote,aNotes);

   974 	}

   975 

   976 void CTestContact::SetIMAddressL(const TDesC& aIMAddress, TUid aAddOnContentType)

   977 	{

   978 	SetTextFieldL(KUidContactFieldIMAddress, aIMAddress, aAddOnContentType);

   979 	}

   980 

   981 void CTestContact::InsertTextFieldL(TFieldType aID, const TDesC& aStringOfStuff )

   982 	{

   983 	CContactItemField* itemFieldPtr = NULL;

   984 	CContactTextField* textStoragePtr = NULL;

   985 

   986 	itemFieldPtr = CContactItemField::NewLC( KStorageTypeText, aID );

   987 	textStoragePtr = itemFieldPtr->TextStorage(); // we don't have ownership here, hence no stack.

   988 

   989 	textStoragePtr->SetTextL( aStringOfStuff );

   990 	textStoragePtr = NULL; // we've finished with this ptr now.

   991 

   992 	iContactItem->AddFieldL( *itemFieldPtr ); // hand ownership over here

   993 	CleanupStack::Pop( itemFieldPtr ); // and pop,

   994 	}

   995 

   996 void CTestContact::SetVoiceDialL(const TDesC& aVoiceDial)

   997 	{

   998 	SetTextFieldL( KUidContactsVoiceDialField, aVoiceDial );

   999 	}

  1000 

  1001 void CTestContact::SetRingToneL(const TDesC& aRingTone)

  1002 	{

  1003 	SetTextFieldL( KUidContactFieldRingTone, aRingTone );

  1004 	}

  1005 

  1006 const TPtrC CTestContact::TextFieldL(TFieldType aFieldType) const

  1007 	{

  1008 	CContactItemField& field=FindFieldL(aFieldType);

  1009 	ASSERT(field.StorageType()==KStorageTypeText);

  1010 	return STATIC_CAST(CContactTextField*,field.Storage())->Text();

  1011 	}

  1012 

  1013 const TPtrC CTestContact::TextFieldL(const CContentType& aTypesToMatch) const

  1014 	{

  1015 	CContactItemField& field=FindFieldL(aTypesToMatch);

  1016 	ASSERT(field.StorageType()==KStorageTypeText);

  1017 	return STATIC_CAST(CContactTextField*,field.Storage())->Text();

  1018 	}

  1019 

  1020 // CHANGE, the original SetTextFieldL is const ?!

  1021 // ----- Seems really daft since even the very name of the function

  1022 // ----- implies that it's modifying data... "SetXXXXX"

  1023 void CTestContact::SetTextFieldL(TFieldType aFieldType,const TDesC& aText)

  1024 	{

  1025 	CContactItemFieldSet& fields = iContactItem->CardFields();

  1026 	TInt fieldIndex = 0;

  1027 

  1028 	fieldIndex = FindField( aFieldType );

  1029 

  1030 	if ( fieldIndex > KErrNotFound )

  1031 		{

  1032 		CContactItemField& field = fields[ fieldIndex ];

  1033 		ASSERT(field.StorageType()==KStorageTypeText);

  1034 		STATIC_CAST(CContactTextField*,field.Storage())->SetText(aText.AllocL());

  1035 		}

  1036 	else

  1037 		{

  1038 		InsertTextFieldL(aFieldType, aText);

  1039 		}

  1040 	}

  1041 

  1042 void CTestContact::SetTextFieldL(const CContentType& aTypesToMatch,const TDesC& aText) const

  1043 	{

  1044 	CContactItemField& field=FindFieldL(aTypesToMatch);

  1045 	ASSERT(field.StorageType()==KStorageTypeText);

  1046 	STATIC_CAST(CContactTextField*,field.Storage())->SetText(aText.AllocL());

  1047 	}

  1048 

  1049 void CTestContact::SetTextFieldL(TFieldType aFieldType, const TDesC& aText, TUid aAddOnContentType) 

  1050 	{

  1051 	CContactItemFieldSet& fields = iContactItem->CardFields();

  1052 	CContactTextField* textField = NULL;

  1053 	TInt fieldIndex = 0;

  1054 

  1055 	fieldIndex = FindField( aFieldType );

  1056 

  1057 	if (fieldIndex == KErrNotFound )

  1058 		{

  1059 		InsertTextFieldL( aFieldType, aText );

  1060 		fieldIndex = FindField( aFieldType );

  1061 		CContactItemField& field = fields[ fieldIndex ];

  1062 		field.AddFieldTypeL( aAddOnContentType );

  1063 		}

  1064 	else if (fieldIndex >= KErrNone )

  1065 		{

  1066 		

  1067 		CContactItemField& field = fields[ fieldIndex ];

  1068 		ASSERT(field.StorageType()==KStorageTypeText);

  1069 		textField = static_cast<CContactTextField*>(field.Storage());

  1070 		textField->SetText( aText.AllocL() );

  1071 		field.AddFieldTypeL( aAddOnContentType );

  1072 		}

  1073 	}

  1074 

  1075 CContactItemField& CTestContact::FindFieldL(TFieldType aFieldType) const

  1076 	{

  1077 	CContactItemFieldSet& fields=iContactItem->CardFields();

  1078 	TInt index=fields.Find(aFieldType);

  1079 	User::LeaveIfError(index);

  1080 	return fields[index];

  1081 	}

  1082 

  1083 TInt CTestContact::FindField(TFieldType aFieldType) const

  1084 	{

  1085 	return iContactItem->CardFields().Find( aFieldType );

  1086 	}

  1087 

  1088 CContactItemField& CTestContact::FindFieldL(const CContentType& aTypesToMatch) const

  1089 	{

  1090 	CContactItemFieldSet& fields=iContactItem->CardFields();

  1091 	const TInt numTypesToMatch(aTypesToMatch.FieldTypeCount());

  1092 	const TFieldType mainFieldType(aTypesToMatch.FieldType(0));

  1093 	TInt index=-1;

  1094 	FOREVER

  1095 		{

  1096 		index=fields.FindNext(mainFieldType,index+1);

  1097 		User::LeaveIfError(index);

  1098 

  1099 		CContactItemField& thisPhoneField=fields[index];

  1100 		const CContentType& thisPhoneFieldTypes=thisPhoneField.ContentType();

  1101 		const TInt numFieldTypes(thisPhoneFieldTypes.FieldTypeCount());

  1102 

  1103 		if (numFieldTypes!=numTypesToMatch)

  1104 			{

  1105 			continue;

  1106 			}

  1107 

  1108 		TInt numTypesLeftToMatch=numTypesToMatch;

  1109 		for (TInt ii=0;ii<numFieldTypes;++ii)

  1110 			{

  1111 			TFieldType thisFieldType(thisPhoneFieldTypes.FieldType(ii));

  1112 			for (TInt jj=0;jj<numTypesToMatch;++jj)

  1113 				{

  1114 				TFieldType thisFieldTypeToMatch(aTypesToMatch.FieldType(jj));

  1115 				if (thisFieldType==thisFieldTypeToMatch)

  1116 					{

  1117 					if (--numTypesLeftToMatch<=0)

  1118 						{

  1119 						return thisPhoneField;

  1120 						}

  1121 

  1122 					break;

  1123 					}

  1124 				}

  1125 			}

  1126 		}

  1127 	}

  1128 

  1129 MRandomWordGenerator::~MRandomWordGenerator()

  1130 	{}

  1131 

  1132 //

  1133 // Class that consumes Database events up to a timeout period.

  1134 // At timeout it calls back to a parent class.

  1135 // Timer is reset each time a database event is received.