diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/uigraphicsutils/tef/t_addressstringtokenizer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/uigraphicsutils/tef/t_addressstringtokenizer.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1001 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + + +#include "t_addressstringtokenizer.h" + +// LOCAL CONSTANTS AND MACROS +static const TInt KReadBufSize(256); +static const TInt KFullBufSize(10000); + +_LIT(KTextToBeParsed, "http://www.google.com 23). 9p=71 jee elvis.presley@hotmail.com 07/00-123123? http://wap.google.com (123 45678910?) 127.0555.0555 roskaa 1.3.4.5.6.7.8.9 laatikos (127.0.0.1) a (0802345... ad (+0821898 (*02 +#098"); +_LIT(KTextToBeParsedForPhNoWithMin15Nos, "tekstii... http://www.google.com jeba jee elvis.presley@hotmail.com 0700-12w312312345 habaha 123 45p1234678910 a 127.052355.052355 roskaa 1.3.4.5.6.7.8.9.1.2.3.4.5.6.7 laatikos a"); +_LIT(KTextToBeParsedToCheckPositions, "tekstii... rtsp://www.abcd.com jeba jee elvis.presley@hotmail.com 0700-123123 habaha@luukku.com 123 45678910? lapalaa vielayksi@yahoo.com roskaa"); + +_LIT(KTextToBeParsedForEmailAndURL, "tekstii... https://www.google.com jeba jee ..elvis.presley@hotmail.com.. 127.0.0.1? roskaa ad!d#$?%&c*+-/d@g_mail-1.com"); +_LIT(KTextToBeParsedForInvalidEMail, "tekstii... www.yahoo.com adsadf .@gmail.com akjdl adf@.$ya%hoo.com jeba jee 127.*.0.1 roskaa@"); +_LIT(KPhoneNo1, "07/00-123123"); +_LIT(KPhoneNo2, "123 45678910"); +_LIT(KPhoneNo3, "127.0555.0555"); +_LIT(KPhoneNo4, "1.3.4.5.6.7.8.9"); +_LIT(KPhoneNo5, "0802345"); +_LIT(KPhoneNo6, "+0821898"); +_LIT(KPhoneNo7, "#098"); + +_LIT(KEMail, "elvis.presley@hotmail.com"); +_LIT(KEMail1, "habaha@luukku.com"); +_LIT(KEMail2, "vielayksi@yahoo.com"); +_LIT(KEMail3, "ad!d#$?%&c*+-/d@g_mail-1.com"); + +_LIT(KURL1, "http://www.google.com"); +_LIT(KURL2, "127.0.0.1"); +_LIT(KURL3, "https://www.google.com"); +_LIT(KURL4, "rtsp://www.abcd.com"); +_LIT(KURL5, "http://wap.google.com"); + +/** + Constructor + */ +CT_AddressStringTokenizerStep::CT_AddressStringTokenizerStep() + { + // Call base class method to set up the human readable name for logging*/ + SetTestStepName(KT_AddressStringTokenizerStep); + } + +/** + Destructor + */ +CT_AddressStringTokenizerStep::~CT_AddressStringTokenizerStep() + { + } + +TVerdict CT_AddressStringTokenizerStep::doTestStepL() + { + INFO_PRINTF1(_L("Test Started")); + __UHEAP_MARK; + RunTestCases(); + __UHEAP_MARKEND; + INFO_PRINTF1(_L("Test Finished")); + return TestStepResult(); + } + +void CT_AddressStringTokenizerStep::RunTestCases() + { + TInt err; + SetTestStepID(_L("UIF-ETUL-0001")); + INFO_PRINTF1(_L("Test to search URLs")); + TRAP(err, SearchURLsL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0002")); + INFO_PRINTF1(_L("Test to search EMailAddresses")); + TRAP(err, SearchEMailAddressesL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0003")); + INFO_PRINTF1(_L("Test to search PhoneNumbers")); + TRAP(err, SearchPhoneNumbersL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0004")); + INFO_PRINTF1(_L("Tests for PhoneNos with Min. 3 nos. in a string \n\t\t\t\t\t\t\t when the string is considered as a phone no.\n")); + TRAP(err, SearchPhoneNumbersWithMin3NosL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0005")); + INFO_PRINTF1(_L("Tests for PhoneNos with Min. 8 nos. in a string \n\t\t\t\t\t\t\t when the string is considered as a phone no.\n")); + TRAP(err, SearchPhoneNumbersWithMin8NosL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0006")); + INFO_PRINTF1(_L("Tests for PhoneNos with Min. 15 nos. in a string \n\t\t\t\t\t\t\t when the string is considered as a phone no.\n")); + TRAP(err, SearchPhoneNumbersWithMin15NosL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0007")); + INFO_PRINTF1(_L("Test to search URL's, EMailAddresses, PhoneNumbers")); + TRAP(err, SearchAllL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0008")); + INFO_PRINTF1(_L("Test to check the positions")); + TRAP(err, CheckPositionsL()); + TEST(err == KErrNone); + RecordTestResultL(); + + SetTestStepID(_L("UIF-ETUL-0009")); + INFO_PRINTF1(_L("Test to Parse URI file")); + TRAP(err, ParseURIFileL()); + TEST(err == KErrNone); + RecordTestResultL(); + + TestOOMForAddressStringTokenizer(); + + SetTestStepID(_L("UIF-ETUL-0024")); + INFO_PRINTF1(_L("Test Phone Search Separators")); + TRAP(err, TestPhoneSearchSeparatorsL()); + TEST(err == KErrNone); + RecordTestResultL(); + CloseTMSGraphicsStep(); + } + +/** + @SYMTestCaseID UIF-ETUL-0001 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for 2 URLs present in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs the CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchURLBin\n + which parses the given string and creates an item array consisting of all the URL's found in the string.\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + + @SYMTestExpectedResults The test checks whether + 1. 2 URL's found by CTulAddressStringTokenizer are the correct ones. + 2. Returns zero URLs when text with Invalid URL's is used for parsing. + 3. CTulAddressStringTokenizer::addressString->ItemCount() returns two when the text with 2 valid URL's is parsed + and returns zero when text with Invalid URL's is parsed. + 4. CTulAddressStringTokenizer::Item() returns EFalse when there are no found items in the addressString. + */ +void CT_AddressStringTokenizerStep::SearchURLsL() + { + TBufC<512> str(KTextToBeParsedForEmailAndURL); + + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForEmailAndURL, CTulAddressStringTokenizer::EFindItemSearchURLBin); + + // Get count of found URL's + TInt count(addressString->ItemCount()); + + TEST(count == 2); + + // Get currently selected URL + CTulAddressStringTokenizer::SFoundItem item; + addressString->Item(item); + TPtrC16 url(str.Mid(item.iStartPos, item.iLength)); + TEST(url.Compare(KURL3) == 0); + + // Get next found URL + addressString->NextItem(item); + url.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(url.Compare(KURL2) == 0); + + delete addressString; + + INFO_PRINTF1(_L("Test to search the text with Invalid URLs")); + + _LIT(KTextToBeParsedForInvalidURL, "tekstii... htsp:\\yahoo.com adsadf wws.google.com akjdl httls://sww.google.com jeba jee 127.*.0.1 roskaa"); + addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForInvalidURL, CTulAddressStringTokenizer::EFindItemSearchURLBin); + + // Get count of found URL's + count = addressString->ItemCount(); + TEST(count == 0); + TEST(!addressString->Item(item)); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0002 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for Email Addresses in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs the CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchMailAddressBin\n + which parses the given string and creates an item array consisting of all the Email Addresses found in the string.\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + + @SYMTestExpectedResults The test checks whether + 1. 2 email addresses found by CTulAddressStringTokenizer are the correct ones. + 2. CTulAddressStringTokenizer::NextItem() returns EFalse when no more email addresses are found in the addressString. + 3. Returns zero email addresses when text with Invalid email addresses is used for parsing. + */ +void CT_AddressStringTokenizerStep::SearchEMailAddressesL() + { + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForEmailAndURL, CTulAddressStringTokenizer::EFindItemSearchMailAddressBin); + + TBufC<512> str(KTextToBeParsedForEmailAndURL); + + // Get count of found email addresses + TInt count(addressString->ItemCount()); + TEST(count == 2); + + // Get currently selected email + CTulAddressStringTokenizer::SFoundItem item; + addressString->Item(item); + TPtrC16 emailAddress(str.Mid(item.iStartPos, item.iLength)); + TEST(emailAddress.Compare(KEMail) == 0); + + addressString->NextItem(item); + emailAddress.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(emailAddress.Compare(KEMail3) == 0); + + // Try to get next email address, should fail + TEST(addressString->NextItem(item) == EFalse); + + delete addressString; + + INFO_PRINTF1(_L("Test to search the text with Invalid EMail addresses")); + addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForInvalidEMail, CTulAddressStringTokenizer::EFindItemSearchMailAddressBin); + + // Get count of found EMail Addresses + count = addressString->ItemCount(); + TEST(count == 0); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0003 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for phone numbers in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs the CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin \n + which parses the given string and creates an item array consisting of all the phone numbers found in the string.\n + 3 is the minimun count of numbers in a string that the string is considered as a phone number when phone numbers are + searched.API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases);\n + CTulAddressStringTokenizer::ItemArray(); \n + + @SYMTestExpectedResults The test checks whether + 1. 7 Phone numbers found by CTulAddressStringTokenizer are the correct ones. + 2. CTulAddressStringTokenizer::ItemArray() returns correct array of phone numbers. + 3. Returns zero phone numbers when text with Invalid phone numbers is used for parsing. + */ +void CT_AddressStringTokenizerStep::SearchPhoneNumbersL() + { + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin); + + TBufC<512> str(KTextToBeParsed); + + const CArrayFixFlat* itemArray = addressString->ItemArray(); + + // Get count of found email addresses + TInt count(addressString->ItemCount()); + TEST(count == 7); + + // Get currently selected phone number + TPtrC16 phoneNos(str.Mid((*itemArray)[0].iStartPos, (*itemArray)[0].iLength)); + TEST(phoneNos.Compare(KPhoneNo1) == 0); + + // Get next found number + phoneNos.Set(str.Mid((*itemArray)[1].iStartPos, (*itemArray)[1].iLength)); + TEST(phoneNos.Compare(KPhoneNo2) == 0); + + // Get next found number + phoneNos.Set(str.Mid((*itemArray)[2].iStartPos, (*itemArray)[2].iLength)); + TEST(phoneNos.Compare(KPhoneNo3) == 0); + + // Get next found number + phoneNos.Set(str.Mid((*itemArray)[3].iStartPos, (*itemArray)[3].iLength)); + TEST(phoneNos.Compare(KPhoneNo4) == 0); + + // Get next found number + phoneNos.Set(str.Mid((*itemArray)[4].iStartPos, (*itemArray)[4].iLength)); + TEST(phoneNos.Compare(KPhoneNo5) == 0); + + // Get next found number + phoneNos.Set(str.Mid((*itemArray)[5].iStartPos, (*itemArray)[5].iLength)); + TEST(phoneNos.Compare(KPhoneNo6) == 0); + + // Get next found number + phoneNos.Set(str.Mid((*itemArray)[6].iStartPos, (*itemArray)[6].iLength)); + TEST(phoneNos.Compare(KPhoneNo7) == 0); + + // Get last found number again + phoneNos.Set(str.Mid((*itemArray)[5].iStartPos, (*itemArray)[5].iLength)); + TEST(phoneNos.Compare(KPhoneNo6) == 0); + + delete addressString; + + INFO_PRINTF1(_L("Test to search the text with Invalid Phone nos.")); + _LIT(KTextToBeParsedForInvalidPhoneNos, "jeba jee 070@0-1231#23 habaha 123 456^78910? roskaa laatikos a"); + + addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForInvalidPhoneNos, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin, 8); + + count= addressString->ItemCount(); + TEST(count == 0); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0004 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for phone numbers containing minimum 3 numbers, in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs the CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin\n + which parses the given string and creates an item array consisting of all the phone numbers containing minimum 3 numbers, found in the string.\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases, TInt aMinNumbers);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + + @SYMTestExpectedResults The test checks whether + 1. 7 Phone numbers found by CTulAddressStringTokenizer are the correct ones. + */ +void CT_AddressStringTokenizerStep::SearchPhoneNumbersWithMin3NosL() + { + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin, 3); + + TBufC<512> str(KTextToBeParsed); + + // Get count of found email addresses + TInt count(addressString->ItemCount()); + TEST(count == 7); + + // Get currently selected phone number + CTulAddressStringTokenizer::SFoundItem item; + addressString->Item(item); + TPtrC16 phoneNos(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo1) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo2) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo3) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo4) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo5) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo6) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo7) == 0); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0005 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for phone numbers containing minimum 8 numbers, in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs the CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin\n + which parses the given string and creates an item array consisting of all the phone numbers containing minimum 8 numbers, found in the string.\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases, TInt aMinNumbers);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + CTulAddressStringTokenizer::PrevItem(SFoundItem& aItem); \n + + @SYMTestExpectedResults The test checks whether + 1. 4 Phone numbers found by CTulAddressStringTokenizer are the correct ones. + 2. CTulAddressStringTokenizer::PrevItem() returns EFalse when called for the first time on addressString + array(ie., when addressString is pointing to the first item in the array). + 3. CTulAddressStringTokenizer::PrevItem() returns correct phone number if it is called after accessing + the last item in the addressString array. + */ +void CT_AddressStringTokenizerStep::SearchPhoneNumbersWithMin8NosL() + { + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin, 8); + + TBufC<512> str(KTextToBeParsed); + + // Get count of found email addresses + TInt count(addressString->ItemCount()); + TEST(count == 4); + + CTulAddressStringTokenizer::SFoundItem item; + + // Try to get a previous item + TEST(!addressString->PrevItem(item)); + + // Get currently selected phone number + addressString->Item(item); + TPtrC16 phoneNos(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo1) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo2) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo3) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo4) == 0); + + // Get last found number again + addressString->PrevItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNo3) == 0); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0006 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for phone numbers containing minimum 15 numbers, in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs the CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin\n + which parses the given string and creates an item array consisting of all the phone numbers containing minimum 15 numbers, found in the string.\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases, TInt aMinNumbers);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + + @SYMTestExpectedResults The test checks whether + 1. 4 Phone numbers found by CTulAddressStringTokenizer are the correct ones. + 2. CTulAddressStringTokenizer::PrevItem() returns correct phone number if it is called after accessing + the last item in the addressString array. + */ +void CT_AddressStringTokenizerStep::SearchPhoneNumbersWithMin15NosL() + { + _LIT(KPhoneNoWithMin15no1, "0700-12w312312345"); + _LIT(KPhoneNoWithMin15no2, "123 45p1234678910"); + _LIT(KPhoneNoWithMin15no3, "127.052355.052355"); + _LIT(KPhoneNoWithMin15no4, "1.3.4.5.6.7.8.9.1.2.3.4.5.6.7"); + + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForPhNoWithMin15Nos, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin, 15); + + TBufC<512> str(KTextToBeParsedForPhNoWithMin15Nos); + + // Get count of found email addresses + TInt count(addressString->ItemCount()); + TEST(count == 4); + + // Get currently selected phone number + CTulAddressStringTokenizer::SFoundItem item; + addressString->Item(item); + TPtrC16 phoneNos(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNoWithMin15no1) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNoWithMin15no2) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNoWithMin15no3) == 0); + + // Get next found number + addressString->NextItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNoWithMin15no4) == 0); + + // Get last found number again + addressString->PrevItem(item); + phoneNos.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(phoneNos.Compare(KPhoneNoWithMin15no3) == 0); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0007 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for Phone numbers, Email addresses and URL's in the string. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs three CTulAddressStringTokenizer objects with CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin\n + CTulAddressStringTokenizer::EFindItemSearchMailAddressBin and CTulAddressStringTokenizer::EFindItemSearchURLBin, + which parses the given string and creates an item array consisting of all the Phone numbers, Email addresses and URL's \n + respectively found in the string.\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + CTulAddressStringTokenizer::DoNewSearchL( const TDesC& aText, TInt aSearchCases); \n + + @SYMTestExpectedResults The test checks whether + 1. Phone numbers, Email addresses and URL's found by CTulAddressStringTokenizer are the correct ones. + 2. CTulAddressStringTokenizer::DoNewSearchL() returns correct addressString array. + */ +void CT_AddressStringTokenizerStep::SearchAllL() + { + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchMailAddressBin); + + TBufC<512> str(KTextToBeParsed); + + // Get count of found email addresses + TInt count(addressString->ItemCount()); + + TEST(count == 1); + + // Get currently selected email + CTulAddressStringTokenizer::SFoundItem item; + addressString->Item(item); + TPtrC16 result(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KEMail) == 0); + + //make a new search - search for URL + addressString->DoNewSearchL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchURLBin); + + count = addressString->ItemCount(); + TEST(count == 3); + + // Get currently selected URL + addressString->Item(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KURL1) == 0); + + // Get next selected URL + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KURL5) == 0); + + // Get next selected URL + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KURL2) == 0); + + //make a new search - search for phone number + addressString->DoNewSearchL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin); + + count = addressString->ItemCount(); + TEST(count == 7); + + // Get selected phone number + addressString->Item(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo1) == 0); + + // Get next selected phone number + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo2) == 0); + + // Get next selected phone number + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo3) == 0); + + // Get next selected phone number + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo4) == 0); + + // Get next selected phone number + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo5) == 0); + + // Get next selected phone number + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo6) == 0); + + // Get next selected phone number + addressString->NextItem(item); + result.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KPhoneNo7) == 0); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0008 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to search for email addresses in the string and verifies their positions. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchMailAddressBin|EFindItemSearchURLBin \n + which parses the given string and creates an item array consisting of all the Email addresses and URL's\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem);\n + CTulAddressStringTokenizer::ResetPosition();\n + + @SYMTestExpectedResults The test checks whether + 1. Phone numbers, Email addresses and URL's found by CTulAddressStringTokenizer are the correct ones. + 2. CTulAddressStringTokenizer::ResetPosition() resets the position of the addressString array to zero. + */ +void CT_AddressStringTokenizerStep::CheckPositionsL() + { + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedToCheckPositions, (CTulAddressStringTokenizer::TTokenizerSearchCase)(CTulAddressStringTokenizer::EFindItemSearchMailAddressBin | CTulAddressStringTokenizer::EFindItemSearchURLBin)); + + TBufC<512> str(KTextToBeParsedToCheckPositions); + + //Get count of found email addresses + TInt count(addressString->ItemCount()); + TEST(count == 4); + + // Get currently selected email + CTulAddressStringTokenizer::SFoundItem item; + addressString->Item(item); + TPtrC16 result(str.Mid(item.iStartPos, item.iLength)); + TEST(result.Compare(KURL4) == 0); + + addressString->NextItem(item); + TPtrC16 result1(str.Mid(item.iStartPos, item.iLength)); + TEST(result1.Compare(KEMail) == 0); + + //move to next item + addressString->NextItem(item); + TPtrC16 result2(str.Mid(item.iStartPos, item.iLength)); + TEST(result2.Compare(KEMail1) == 0); + + //check that position is correct + TEST(addressString->Position() == 2); + + //move to next item + addressString->NextItem(item); + result2.Set(str.Mid(item.iStartPos, item.iLength)); + TEST(result2.Compare(KEMail2) == 0); + + //Resets the position to zero + addressString->ResetPosition(); + //get the first item + addressString->Item(item); + + TPtrC16 reset_result1(str.Mid(item.iStartPos, item.iLength)); + TEST(reset_result1.Compare(KURL4) == 0); + + //verify that we are in first item + TEST(result == reset_result1); + + delete addressString; + } + +/** + @SYMTestCaseID UIF-ETUL-0009 + + @SYMREQ 7736 + + @SYMTestCaseDesc Test to Parse for URI's, Email Addresses, Phone Numbers and URL's in a file and to verify them + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Constructs CTulAddressStringTokenizer object with CTulAddressStringTokenizer::EFindItemSearchMailAddressBin \n + which parses the given string and creates an item array consisting of all the Email addresses\n + API Calls:\n + CTulAddressStringTokenizer::NewL(const TDesC& aText, TInt aSearchCases);\n + CTulAddressStringTokenizer::Item(SFoundItem& aItem); \n + CTulAddressStringTokenizer::NextItem(SFoundItem& aItem); \n + + @SYMTestExpectedResults The test checks whether + 1. Phone numbers, Email addresses, URL's and URI's parsed by CTulAddressStringTokenizer are the correct ones. + */ +void CT_AddressStringTokenizerStep::ParseURIFileL() + { + INFO_PRINTF1(_L("Test begins")); + __UHEAP_MARK; + + //load test case text to string + RFs rfs; + User::LeaveIfError(rfs.Connect()); + CleanupClosePushL(rfs); + _LIT(KParesTextFile, "z:\\system\\data\\addressstringtokenizertestappdata.txt"); + _LIT(KParesTextFileRef, "z:\\system\\data\\addressstringtokenizertestappdataref.txt"); + + RFile file; + HBufC* fullBuf = HBufC::NewMaxLC(KFullBufSize); + TPtr fullBufPtr = fullBuf->Des(); + fullBufPtr = KNullDesC; + + TFileText reader; + TBuf fileBuffer; + + if ((file.Open(rfs, KParesTextFile, EFileStreamText|EFileRead|EFileShareAny)) == KErrNone) + { + CleanupClosePushL(file); + // use TFileText for reading file. There is probably better ways to do this tho. + reader.Set(file); + if (reader.Seek(ESeekStart)) + { + INFO_PRINTF1(_L("File corrupted")); + User::Leave(KErrGeneral); // not cleaning up properly + } + + while (!reader.Read(fileBuffer)) + { + fullBufPtr.Append(fileBuffer); + fullBufPtr.Append('\n'); + } + CleanupStack::Pop(&file); + file.Close(); + } + else + { + INFO_PRINTF1(_L("z:\\system\\data\\addressstringtokenizertestappdata.txt not found")); + User::Leave(KErrNotFound); + } + + if (file.Open(rfs, KParesTextFileRef, EFileStreamText|EFileRead|EFileShareAny) == KErrNone) + { + CleanupClosePushL(file); + // use TFileText for reading file. There is probably better way to do this tho. + reader.Set(file); + if (reader.Seek(ESeekStart)) + { + INFO_PRINTF1(_L("File corrupted")); + User::Leave(KErrGeneral); // not cleaning up properly + } + } + else + { + INFO_PRINTF1(_L("z:\\system\\data\\addressstringtokenizertestappdataref.txt not found")); + User::Leave(KErrNotFound); + } + + INFO_PRINTF1(_L("Start searching...")); + + // Create an instance of Address String Tokenizer and search for URL's. + CTulAddressStringTokenizer* addressString = CTulAddressStringTokenizer::NewL(fullBufPtr, CTulAddressStringTokenizer::EFindItemSearchURLBin); + TestAddressStringTokenizers(addressString, reader, fullBufPtr); + delete addressString; + + // find phone numbers from same text + addressString = CTulAddressStringTokenizer::NewL(fullBufPtr, CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin); + TestAddressStringTokenizers(addressString, reader, fullBufPtr); + + // test do new search with same instance + TInt count = addressString->DoNewSearchL(fullBufPtr, CTulAddressStringTokenizer::EFindItemSearchMailAddressBin); + TEST(count > 0); + TestAddressStringTokenizers(addressString, reader, fullBufPtr); + delete addressString; + + // find schemed URIs from same text + addressString = CTulAddressStringTokenizer::NewL(fullBufPtr, CTulAddressStringTokenizer::EFindItemSearchScheme); + TestAddressStringTokenizers(addressString, reader, fullBufPtr); + delete addressString; + + // find everything from same text + addressString = CTulAddressStringTokenizer::NewL(fullBufPtr, (CTulAddressStringTokenizer::TTokenizerSearchCase)(CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin | CTulAddressStringTokenizer::EFindItemSearchURLBin | CTulAddressStringTokenizer::EFindItemSearchMailAddressBin | CTulAddressStringTokenizer::EFindItemSearchScheme)); + TestAddressStringTokenizers(addressString, reader, fullBufPtr); + delete addressString; + + CleanupStack::PopAndDestroy(3, &rfs); + __UHEAP_MARKEND; + } + +/** + @SYMTestCaseID UIF-ETUL-0010 + + @SYMREQ 7736 + + @SYMTestCaseDesc OOM test for CTulAddressStringTokenizer's NewL() and DoNewSearchL() methods. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Calls CTulAddressStringTokenizer's NewL() and DoNewSearchL() methods. + + @SYMTestExpectedResults Tests should complete without any memory leaks. + */ +void CT_AddressStringTokenizerStep::TestOOMForAddressStringTokenizer() + { + INFO_PRINTF1(_L("Start OOM test for Address String Tokenizer")); + CTulAddressStringTokenizer* addressString = NULL; + TInt count; + TInt fail; + + //OOM test for CTulAddressStringTokenizer::NewL() method. + for (fail = 1;; fail++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic, fail); + __UHEAP_MARK; + TRAPD(err, addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForEmailAndURL, CTulAddressStringTokenizer::EFindItemSearchURLBin)); + TEST((err == KErrNone) || (err == KErrNoMemory)); + if (err == KErrNone) + { + // Get count of found URL's + count = addressString->ItemCount(); + TEST(count == 2); + delete addressString; + addressString = NULL; + __UHEAP_MARKEND; + break; + } + __UHEAP_MARKEND; + } + + //OOM test for CTulAddressStringTokenizer::DoNewSearchL() method. + for (fail = 1; ; fail++) + { + __UHEAP_RESET; + TRAPD(err, addressString = CTulAddressStringTokenizer::NewL(KTextToBeParsedForEmailAndURL, CTulAddressStringTokenizer::EFindItemSearchURLBin)); + TEST(err == KErrNone); + + __UHEAP_SETFAIL(RHeap::EDeterministic, fail); + __UHEAP_MARK; + TRAP(err, count = addressString->CTulAddressStringTokenizer::DoNewSearchL(KTextToBeParsed, CTulAddressStringTokenizer::EFindItemSearchMailAddressBin)); + TEST((err == KErrNone) || (err == KErrNoMemory)); + if (err == KErrNone) + { + // Get count of found URL's + count = addressString->ItemCount(); + TEST(count == 1); + delete addressString; + __UHEAP_MARKEND; + break; + } + else + { + delete addressString; + __UHEAP_MARKEND; + } + } + __UHEAP_RESET; + INFO_PRINTF1(_L("OOM test for Address String Tokenizer Completed")); + } + +void CT_AddressStringTokenizerStep::TestAddressStringTokenizers(CTulAddressStringTokenizer* aAddressStringTokenizer, TFileText& aReader, TDes& aText) + { + TBuf fileBuffer; + + // Get count of found items. + TInt count(aAddressStringTokenizer->ItemCount()); + TEST(count > 0); + TPtrC result; + + // SFoundItem instance + CTulAddressStringTokenizer::SFoundItem item; + + TBool found = aAddressStringTokenizer->Item(item); + TEST(found); + for(TInt i = 0; i < count; i++) + { + result.Set(aText.Mid(item.iStartPos, item.iLength)); + aReader.Read(fileBuffer); + + //Comparing parsed result to what read buffer reads from the file. + TEST(!fileBuffer.Compare(result) ); + if (fileBuffer.Compare(result)) + { + INFO_PRINTF2(_L("Buffer : %S"), &fileBuffer); + INFO_PRINTF2(_L("Result : %S"), &result); + } + aAddressStringTokenizer->NextItem(item); + } + } + +/** + @SYMTestCaseID UIF-ETUL-0024 + + @SYMREQ DEF114388 + + @SYMTestCaseDesc Test of CTulAddressStringTokenizer::SearchPhoneNumberL( const TDesC& aText ) + with all the phone number separators. + + @SYMTestPriority Normal + + @SYMTestStatus Implemented + + @SYMTestActions There should be 5 phone numbers separators: + - KCharLinefeed = 0x000A + - KCharFormfeed = 0x000C + - KCharCarriageReturn = 0x000D + - KCharLineSeparator = 0x2028 + - KCharParagraphSeparator = 0x2029 + With a simple string _LIT16(KTestPhoneSeparator, "11111%c22222") + and with all the separators above, we apply the tested function: + CTulAddressStringTokenizer::SearchPhoneNumberL( const TDesC& aText ) + + + @SYMTestExpectedResults On the 5 cases, the function should find 2 phone numbers + i.e: multiSearch->ItemCount() should be equal to 2 + otherwise the test fail. + */ +void CT_AddressStringTokenizerStep::TestPhoneSearchSeparatorsL() + { + TInt KCharLinefeed = 0x000A; + TInt KCharFormfeed = 0x000C; + TInt KCharCarriageReturn = 0x000D; + TInt KCharLineSeparator = 0x2028; + TInt KCharParagraphSeparator = 0x2029; + TInt KSeparators[5]={KCharLinefeed,KCharFormfeed,KCharCarriageReturn,KCharLineSeparator,KCharParagraphSeparator}; + _LIT16(KTestPhoneSeparator, "11111%c22222"); + TBool succeed=ETrue; + TBuf16<16> str; + for (TInt k=0;k<5;k++) + { + str.Format(KTestPhoneSeparator,KSeparators[k]); + CTulAddressStringTokenizer* multiSearch = CTulAddressStringTokenizer::NewL(str, + CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin); + + if (multiSearch->ItemCount()!=2) + { + succeed=EFalse; + } + delete multiSearch; + if (succeed==EFalse) + { + break; + } + } + TEST(succeed); + }