diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/msgtest/integration/sms/src/T_smut.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/msgtest/integration/sms/src/T_smut.cpp Wed Nov 03 22:41:46 2010 +0530 @@ -0,0 +1,1237 @@ +// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "T_smcm.h" +#include +#include +#include +#include + +using namespace CommsDat; + + #include + +CSmutTest::CSmutTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest) +: CSmsTestBase(aSmsTest, aScriptFile, aNextTest) + { + } + +void CSmutTest::RunAutoL() + { + // Testing settings (CSmsSettings) + iSmsTest.TestStart(++iNextTest, _L("CSmsSettings")); + TestSettingsL(); + iSmsTest.TestFinish(iNextTest); + + // Testing number class (CSmsNumber) + iSmsTest.TestStart(++iNextTest, _L("CSmsNumber")); + TestNumberL(); + iSmsTest.TestFinish(iNextTest); + + // Testing with header (CSmsHeader) + iSmsTest.TestStart(++iNextTest, _L("CSmsHeader")); + TestHeaderL(); + iSmsTest.TestFinish(iNextTest); + + // Testing with utility class (TSmsUtilities) + iSmsTest.TestStart(++iNextTest, _L("TSmsUtilities")); + TestSmsUtilitiesL(); + iSmsTest.TestFinish(iNextTest); + + } + +CSmutTest::~CSmutTest() + { + delete iSmsHeader; + delete iRichText; + delete iParaLayer; + delete iCharLayer; + } + +void CSmutTest::ConstructL() + { + SetTestNameL(KSmsUtilitiesTestName); + iSmsTest.SetLogToFile(); + + iSelection = new (ELeave) CMsvEntrySelection(); + iTimer = CTestTimer::NewL(); + + iParaLayer =CParaFormatLayer::NewL(); + iCharLayer = CCharFormatLayer::NewL(); + iRichText = CRichText::NewL(iParaLayer, iCharLayer, CEditableText::EFlatStorage,256); + CActiveScheduler::Add(this); + } + +CSmutTest* CSmutTest::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest) + { + CSmutTest* self = new (ELeave) CSmutTest(aSmsTest, aScriptFile, aNextTest); + CleanupStack::PushL(self); + + self->ConstructL(); + + return self; + } + +void CSmutTest::ShowMenuL() + { + iSmsTest.ResetMenu(); + + iSmsTest.AppendToMenuL(_L("Start")); + + TInt result = iSmsTest.DisplayMenu(_L("SMS Client MTM Test")); + + if (result <= 0) + return; + + switch (result) + { + case 1: + RunAutoL(); + break; + default: + User::Leave(KErrArgument); + break; + } + + if (!iSmsTest.RunAuto()) + { + iSmsTest.Printf(_L("Press any key to continue...\n")); + iSmsTest.Test().Getch(); + } + + ShowMenuL(); + } + +void CSmutTest::TestSettingsL() + { + iSmsTest.Printf(_L("Testing Create Settings...\n")); + + iSmsTest.SetEntryL(iSmsTest.iSmsServiceId); + +// First we test all the features of the class CSmsSettings +// We give them different values and compare if it works + + CSmsSettings* settings = CSmsSettings::NewL(); + CleanupStack::PushL(settings); + iSmsTest(CompareSettings(*settings, *settings)); + TestSettingsMembersL(*settings); + TestMessageSettingsMembersL(*settings); + +// Lets copy the values to a different instance + CSmsSettings* smsSettings=CSmsSettings::NewL(); + CleanupStack::PushL(smsSettings); + smsSettings->CopyL(*settings); + iSmsTest(CompareSettings(*smsSettings, *settings)); + CleanupStack::PopAndDestroy(smsSettings); + smsSettings = NULL; + iSmsTest.Printf(_L("Test CSmsSettings::CopyL() passed\n")); + +// Lets create a sms service in the file system with these values + StoreSettingsL(*settings); + + iSmsTest.Printf(_L("Stored CSmsSettings against the service\n")); + +// Lets read the service and see it the values are still ok + CSmsSettings* set1=CSmsSettings::NewL(); + CleanupStack::PushL(set1); + + RestoreSettingsL(*set1); + + iSmsTest.Printf(_L("Restored CSmsSettings\n")); + + iSmsTest(CompareSettings(*set1, *settings)); + + CleanupStack::PopAndDestroy(set1); + +// Lets make the previous test again; Lets give a settings instance some +// values, store it, restore it and see that the values are still the same + CSmsSettings* set2=CSmsSettings::NewL(); + CleanupStack::PushL(set2); + set2->AddServiceCenterL(_L("Radiolinja0"),_L("+358508771010")); + set2->AddServiceCenterL(_L("Radiolinja1"),_L("+358508771010")); + set2->AddServiceCenterL(_L("Radiolinja2"),_L("+358508771010")); + set2->AddServiceCenterL(_L("Radiolinja3"),_L("+358508771010")); + set2->AddServiceCenterL(_L("Radiolinja4"),_L("+358508771010")); + set2->SetDefaultServiceCenter(1); + iSmsTest(set2->DefaultServiceCenter()==1); +// Validity Period + set2->SetValidityPeriod(ESmsVPSixHours); + iSmsTest(set2->ValidityPeriod().Int()==ESmsVPSixHours); +// Reply Quoted + set2->SetReplyQuoted(EFalse); + iSmsTest(!set2->ReplyQuoted()); +// Reject Duplicate + set2->SetRejectDuplicate(ETrue); + iSmsTest(set2->RejectDuplicate()); +// Delivery Method + set2->SetDelivery(ESmsDeliveryUponRequest); + iSmsTest(set2->Delivery()==ESmsDeliveryUponRequest); +// Delivery Report + set2->SetDeliveryReport(ETrue); + iSmsTest(set2->DeliveryReport()); +// Reply Path + set2->SetReplyPath(EFalse); + iSmsTest(!set2->ReplyPath()); +// Message Conversion + set2->SetMessageConversion(ESmsConvPIDNone); + iSmsTest(set2->MessageConversion()==ESmsConvPIDNone); +// Can Concatenate + set2->SetCanConcatenate(ETrue); + iSmsTest(set2->CanConcatenate()); +// Character Set + set2->SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit); + iSmsTest(set2->CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet8Bit); +// Validity period format + set2->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet); + iSmsTest(set2->ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFSemiOctet); +// Status Report Handling + set2->SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible); + iSmsTest(set2->StatusReportHandling()==CSmsSettings::EMoveReportToInboxVisible); +// Special Message Handling + set2->SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible); + iSmsTest(set2->SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxVisible); + + StoreSettingsL(*set2); + + iSmsTest.Printf(_L("Stored CSmsSettings 2\n")); + + + CSmsSettings* set3=CSmsSettings::NewL(); + CleanupStack::PushL(set3); + + RestoreSettingsL(*set3); + + iSmsTest.Printf(_L("Restored CSmsSettings 2\n")); + + iSmsTest(CompareSettings(*set2, *set3)); + + CleanupStack::PopAndDestroy(set3); + CleanupStack::PopAndDestroy(set2); + + iSmsTest.iServiceSettings->CopyL(*settings); // Lets copy the current setting to the service settings + + iSmsTest(CompareSettings(*iSmsTest.iServiceSettings, *settings)); + + iSmsTest.Printf(_L("CSmsSettings::CopyL() 2\n")); + + CleanupStack::PopAndDestroy(settings); + + iSmsTest.Printf(_L("Test Create Settings Passed\n")); + + TestSettingsStoreToCommDbL(); + + iSmsTest.Printf(_L("TestSettingsStoreToCommDbL Passed\n")); + + TestSettingsRestoreDefectL(); + + iSmsTest.Printf(_L("TestSettingsRestoreDefectL Passed\n")); + } + +void CSmutTest::TestSettingsMembersL(CSmsSettings& aSettings) + { +// Status Report Handling (what should be done to report messages) + aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisible); + iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxInvisible); + aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisible); + iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxVisible); + aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReport); + iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EDiscardReport); + iSmsTest.Printf(_L("Test Status Report Handling Passed\n")); + +// SC handling + aSettings.AddServiceCenterL(_L("Radiolinja0"),_L("+358508771010")); + aSettings.AddServiceCenterL(_L("Radiolinja1"),_L("+358508771010")); + aSettings.AddServiceCenterL(_L("Radiolinja2"),_L("+358508771010")); + aSettings.AddServiceCenterL(_L("Radiolinja3"),_L("+358508771010")); + aSettings.AddServiceCenterL(_L("Radiolinja4"),_L("+358508771010")); + iSmsTest(aSettings.GetServiceCenter(0).Name()==_L("Radiolinja0")); + aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-3); + aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-2); + iSmsTest(aSettings.GetServiceCenter(1).Name()==_L("Radiolinja1")); + iSmsTest(aSettings.GetServiceCenter(2).Name()==_L("Radiolinja4")); + iSmsTest(aSettings.GetServiceCenter(2).Address()==_L("+358508771010")); + aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1); + aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1); + aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1); +// aSettings.RemoveServiceCenter(aSettings.ServiceCenterCount()-1); // this would be -1 + aSettings.AddServiceCenterL(_L("Radiolinja0"),_L("+358508771010")); + aSettings.AddServiceCenterL(_L("Radiolinja1"),_L("+358508771010")); + aSettings.AddServiceCenterL(_L("Radiolinja2"),_L("+358508771010")); + aSettings.SetDefaultServiceCenter(1); + iSmsTest(aSettings.DefaultServiceCenter()==1); + aSettings.SetDefaultServiceCenter(2); + iSmsTest(aSettings.DefaultServiceCenter()==2); + iSmsTest.Printf(_L("Test Default SC Passed\n")); + + +// Special Message Handling (what should be done to special messages) + aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisible); + iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxInvisible); + aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisible); + iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxVisible); + aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReport); + iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EDiscardReport); + iSmsTest.Printf(_L("Test Special Message Handling Passed\n")); + +//CommDbAction + aSettings.SetCommDbAction(CSmsSettings::ENone); + iSmsTest(aSettings.CommDbAction() == CSmsSettings::ENone); + aSettings.SetCommDbAction(CSmsSettings::EStoreToCommDb); + iSmsTest(aSettings.CommDbAction() == CSmsSettings::EStoreToCommDb); + iSmsTest.Printf(_L("Test CommDb Action Passed\n")); + +//SmsBearerAction + aSettings.SetSmsBearerAction(CSmsSettings::ENone); + iSmsTest(aSettings.SmsBearerAction() == CSmsSettings::ENone); + aSettings.SetSmsBearerAction(CSmsSettings::EStoreToCommDb); + iSmsTest(aSettings.SmsBearerAction() == CSmsSettings::EStoreToCommDb); + iSmsTest.Printf(_L("Test SMS Bearer Action Passed\n")); + +//SmsBearer + aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly); + iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerPacketOnly); + aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly); + iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerPacketOnly); + aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly); + iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerCircuitOnly); + aSettings.SetSmsBearer(CSmsSettings::ESmsBearerPacketPreferred); + iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerPacketPreferred); + aSettings.SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred); + iSmsTest(aSettings.SmsBearer() == CSmsSettings::ESmsBearerCircuitPreferred); + iSmsTest.Printf(_L("Test SMS Bearer Passed\n")); + +// Reply Quoted + aSettings.SetReplyQuoted(EFalse); + iSmsTest(!aSettings.ReplyQuoted()); + aSettings.SetReplyQuoted(ETrue); + iSmsTest(aSettings.ReplyQuoted()); + iSmsTest.Printf(_L("Test Reply Quoted Passed\n")); + +// Delivery Method + aSettings.SetDelivery(ESmsDeliveryUponRequest); + iSmsTest(aSettings.Delivery()==ESmsDeliveryUponRequest); + aSettings.SetDelivery(ESmsDeliveryScheduled); + iSmsTest(aSettings.Delivery()==ESmsDeliveryScheduled); + aSettings.SetDelivery(ESmsDeliveryImmediately); + iSmsTest(aSettings.Delivery()==ESmsDeliveryImmediately); + iSmsTest.Printf(_L("Test Delivery Passed\n")); + } + +void CSmutTest::TestMessageSettingsMembersL(CSmsMessageSettings& aSettings) + { + +// Reject Duplicate + aSettings.SetRejectDuplicate(ETrue); + iSmsTest(aSettings.RejectDuplicate()); + aSettings.SetRejectDuplicate(EFalse); + iSmsTest(!aSettings.RejectDuplicate()); + iSmsTest.Printf(_L("Test Reject Duplicate Passed\n")); + +// Delivery Report + aSettings.SetDeliveryReport(ETrue); + iSmsTest(aSettings.DeliveryReport()); + aSettings.SetDeliveryReport(EFalse); + iSmsTest(!aSettings.DeliveryReport()); + iSmsTest.Printf(_L("Test Delivery Report Passed\n")); + +// Reply Path + aSettings.SetReplyPath(EFalse); + iSmsTest(aSettings.ReplyPath()==EFalse); + aSettings.SetReplyPath(ETrue); + iSmsTest(aSettings.ReplyPath()); + iSmsTest.Printf(_L("Test Reply Path Passed\n")); + +// Validity period format + aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFNone); + iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFNone); + aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFEnhanced); + iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFEnhanced); + aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger); + iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFInteger); + aSettings.SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet); + iSmsTest(aSettings.ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFSemiOctet); + iSmsTest.Printf(_L("Test Validity Period Format Passed\n")); + +// Message Conversion (following conversions are supported) + aSettings.SetMessageConversion(ESmsConvFax); + iSmsTest(aSettings.MessageConversion()==ESmsConvFax); + aSettings.SetMessageConversion(ESmsConvX400); + iSmsTest(aSettings.MessageConversion()==ESmsConvX400); + aSettings.SetMessageConversion(ESmsConvPaging); + iSmsTest(aSettings.MessageConversion()==ESmsConvPaging); + aSettings.SetMessageConversion(ESmsConvMail); + iSmsTest(aSettings.MessageConversion()==ESmsConvMail); + aSettings.SetMessageConversion(ESmsConvErmes); + iSmsTest(aSettings.MessageConversion()==ESmsConvErmes); + aSettings.SetMessageConversion(ESmsConvSpeech); + iSmsTest(aSettings.MessageConversion()==ESmsConvSpeech); + aSettings.SetMessageConversion(ESmsConvPIDNone); + iSmsTest(aSettings.MessageConversion()==ESmsConvPIDNone); + iSmsTest.Printf(_L("Test Message Conversion Passed\n")); + +// Validity Period + aSettings.SetValidityPeriod(ESmsVPHour); + iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPHour); + aSettings.SetValidityPeriod(ESmsVPSixHours); + iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPSixHours); + aSettings.SetValidityPeriod(ESmsVP24Hours); + iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVP24Hours); + aSettings.SetValidityPeriod(ESmsVPMaximum); + iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPMaximum); + aSettings.SetValidityPeriod(ESmsVPWeek); + iSmsTest(aSettings.ValidityPeriod().Int()==ESmsVPWeek); + iSmsTest.Printf(_L("Test Validity Period Passed\n")); + +// Can Concatenate (write messages with more than 160 characters) + aSettings.SetCanConcatenate(ETrue); + iSmsTest(aSettings.CanConcatenate()); + aSettings.SetCanConcatenate(EFalse); + iSmsTest(aSettings.CanConcatenate()==EFalse); + iSmsTest.Printf(_L("Test Can Concatenate Passed\n")); + +// Character Set (following character sets are supported) + aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit); + iSmsTest(aSettings.CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet7Bit); + aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabetUCS2); + iSmsTest(aSettings.CharacterSet()==TSmsDataCodingScheme::ESmsAlphabetUCS2); + aSettings.SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet8Bit); + iSmsTest(aSettings.CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet8Bit); + iSmsTest.Printf(_L("Test Character Set Passed\n")); + } + +TBool CSmutTest::CompareSettings(const CSmsSettings& aLeft, const CSmsSettings& aRight, TBool aTestSC) + { + TCompare compare(CompareMessageSettings(aLeft, aRight)); + + compare(aLeft.CommDbAction() == aRight.CommDbAction()); + compare(aLeft.SmsBearerAction() == aRight.SmsBearerAction()); + compare(aLeft.SmsBearer() == aRight.SmsBearer()); + compare(aLeft.Delivery() == aRight.Delivery()); + compare(CompareBools(aLeft.ReplyQuoted(), aRight.ReplyQuoted())); + compare(aLeft.SpecialMessageHandling() == aRight.SpecialMessageHandling()); + compare(aLeft.StatusReportHandling() == aRight.StatusReportHandling()); + + if (aTestSC) + { + compare(aLeft.DefaultServiceCenter() == aRight.DefaultServiceCenter()); + compare(aLeft.ServiceCenterCount() == aRight.ServiceCenterCount()); + + TInt count = aLeft.ServiceCenterCount(); + + while (count--) + { + compare(CompareServiceCenters(aLeft.GetServiceCenter(count), aRight.GetServiceCenter(count))); + } + } + + return compare; + } + +TBool CSmutTest::CompareMessageSettings(const CSmsMessageSettings& aLeft, const CSmsMessageSettings& aRight) + { + TCompare compare(CompareBools(aLeft.CanConcatenate(), aRight.CanConcatenate())); + compare(aLeft.CharacterSet() == aRight.CharacterSet()); + compare(CompareBools(aLeft.DeliveryReport(), aRight.DeliveryReport())); + compare(aLeft.MessageConversion() == aRight.MessageConversion()); + compare(CompareBools(aLeft.RejectDuplicate(), aRight.RejectDuplicate())); + compare(CompareBools(aLeft.ReplyPath(), aRight.ReplyPath())); + compare(aLeft.ValidityPeriod() == aRight.ValidityPeriod()); + compare(aLeft.ValidityPeriodFormat() == aRight.ValidityPeriodFormat()); + return compare; + } + +void CSmutTest::TestSettingsRestoreDefectL() + { + //Test fix for defects EDNAALR-4KTKTD (CSmsSettings::RestoreL() should leave if stream not present) + //and EDNAALR-4KTKLP (CSmsSettings::InternalizeL() causes memory leak) + + CSmsSettings* settings = CSmsSettings::NewL(); + CleanupStack::PushL(settings); + + //Test defect fix for EDNAALR-4KTKTD (CSmsSettings::RestoreL() should leave if stream not present) + const TMsvId id = iSmsTest.CreateDummyMessageToSendL(); + Session().CleanupEntryPushL(id); + iSmsTest.SetEntryL(id); + + iSmsTest.Printf(_L("TestSettingsRestoreDefectL Created dummy message\n")); + + TRAPD(err, RestoreSettingsL(*settings)); + + iSmsTest.Printf(_L("TestSettingsRestoreDefectL RestoreL 1 with error %d\n"), err); + iSmsTest.Printf(_L("Expected %d\n"), KErrNotFound); + iSmsTest(err == KErrNotFound); + + //Test defect fix for EDNAALR-4KTKLP (CSmsSettings::InternalizeL() causes memory leak) +// iSmsTest.SetEntryL(id); + StoreSettingsL(*settings); + + iSmsTest.Printf(_L("TestSettingsRestoreDefectL StoreL 1\n")); + + settings->AddServiceCenterL(_L("Unknown"), _L("447785016005")); + + RestoreSettingsL(*settings); + + CleanupStack::PopAndDestroy(); //id + CleanupStack::PopAndDestroy(settings); + iSmsTest.Printf(_L("TestSettingsRestoreDefectL RestoreL 2\n")); + } + +void CSmutTest::TestSettingsStoreToCommDbL() + { + iSmsTest.Test().Next(_L("Storing CSmsSettings to CommDb\n")); + iSmsTest.Printf(_L("Test Store Settings to CommDb\n")); + + CSmsSettings* settings1 = CSmsSettings::NewL(); + CleanupStack::PushL(settings1); + + CSmsSettings* settings2 = CSmsSettings::NewL(); + CleanupStack::PushL(settings2); + + iSmsTest(CompareSettings(*settings1, *settings2)); + + settings1->SetCommDbAction(CSmsSettings::EStoreToCommDb); + settings1->AddServiceCenterL(_L("Vodafone"), _L("+447785016005")); + settings1->SetDeliveryReport(ETrue); + settings1->SetValidityPeriod(1000); + + iSmsTest.SetEntryL(iSmsTest.iSmsServiceId); + + StoreSettingsL(*settings1); + iSmsTest.Printf(_L("\tNew Settings...\n")); + iSmsTest(CompareSettingsAndCommDbL(*settings1)); + + settings1->GetServiceCenter(settings1->DefaultServiceCenter()).SetAddressL(_L("+3854354433")); + + StoreSettingsL(*settings1); + iSmsTest.Printf(_L("\tSC Address Changed...\n")); + iSmsTest(CompareSettingsAndCommDbL(*settings1)); + + settings1->SetDeliveryReport(EFalse); + + StoreSettingsL(*settings1); + iSmsTest.Printf(_L("\tDelivery Report Changed...\n")); + iSmsTest(CompareSettingsAndCommDbL(*settings1)); + + settings1->SetValidityPeriod(2000); + + StoreSettingsL(*settings1); + iSmsTest.Printf(_L("\tValidity Period Changed...\n")); + iSmsTest(CompareSettingsAndCommDbL(*settings1)); + + settings1->GetServiceCenter(settings1->DefaultServiceCenter()).SetAddressL(_L("+48996655888")); + settings1->SetDeliveryReport(ETrue); + settings1->SetValidityPeriod(3000); + + StoreSettingsL(*settings1); + iSmsTest.Printf(_L("\tAll Settings Changed...\n")); + iSmsTest(CompareSettingsAndCommDbL(*settings1)); + + settings1->AddServiceCenterL(_L("Radio"), _L("+385669988")); + settings1->SetDefaultServiceCenter(settings1->ServiceCenterCount()-1); + + StoreSettingsL(*settings1); + iSmsTest.Printf(_L("\tDefaultSC Changed...\n")); + iSmsTest(CompareSettingsAndCommDbL(*settings1)); + + settings1->SetCommDbAction(CSmsSettings::ENone); + settings1->GetServiceCenter(settings1->DefaultServiceCenter()).SetAddressL(_L("+123456789")); + settings1->SetDeliveryReport(EFalse); + settings1->SetValidityPeriod(4000); + + iSmsTest.Printf(_L("\tTesting Setting Different from CommDb...\n")); + iSmsTest(!CompareSettingsAndCommDbL(*settings1)); + + TInt count = settings1->ServiceCenterCount(); + + while (count--) + { + settings1->RemoveServiceCenter(count); + } + + iSmsTest.Printf(_L("\tTesting Setting Different from CommDb...\n")); + iSmsTest(!CompareSettingsAndCommDbL(*settings1)); + + iSmsTest.Printf(_L("\tRestore settings from store...\n")); + RestoreSettingsL(*settings2); + iSmsTest(CompareSettingsAndCommDbL(*settings2)); + +//Test SMS Bearer + + iSmsTest.Printf(_L("\tTest Store SMS Bearer...\n")); + +//Test 1 + + settings1->SetSmsBearerAction(CSmsSettings::EStoreToCommDb); + settings1->SetSmsBearer(CSmsSettings::ESmsBearerPacketOnly); + + StoreSettingsL(*settings1); + iSmsTest(CompareSettingsAndSmsBearerL(*settings1)); + +//Test 2 + + settings1->SetSmsBearer(CSmsSettings::ESmsBearerCircuitOnly); + iSmsTest(!CompareSettingsAndSmsBearerL(*settings1)); + +//Test 3 + + StoreSettingsL(*settings1); + iSmsTest(CompareSettingsAndSmsBearerL(*settings1)); + + RestoreSettingsL(*settings2); + iSmsTest(CompareSettingsAndSmsBearerL(*settings2)); + +//Test 4 + + settings1->SetSmsBearerAction(CSmsSettings::ENone); + StoreSettingsL(*settings1); + iSmsTest(CompareSettingsAndSmsBearerL(*settings1)); + +//Test 5 + + settings1->SetSmsBearer(CSmsSettings::ESmsBearerCircuitPreferred); + iSmsTest(!CompareSettingsAndSmsBearerL(*settings1)); + StoreSettingsL(*settings1); + iSmsTest(!CompareSettingsAndSmsBearerL(*settings1)); + + CleanupStack::PopAndDestroy(2); //settings1, settings2 + } + +TBool CSmutTest::CompareSettingsAndCommDbL(const CSmsSettings& aSettings) const + { + TCompare compare = ETrue; + + TBuf<256> scAddress; + CMDBSession* iDBSession = CMDBSession::NewL(CMDBSession::LatestVersion()); + CMDBRecordSet globalSettingsRecord(KCDTIdGlobalSettingsRecord); + TRAPD(err, globalSettingsRecord.LoadL(*iDBSession)); + if(err != KErrNone) + { + User::Leave(KErrNotFound); + } + + CCDModemBearerRecord *modemBearerRecord = static_cast(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord)); + CleanupStack::PushL(modemBearerRecord); + modemBearerRecord->SetRecordId(((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iModemForPhoneServicesAndSMS); + modemBearerRecord->LoadL(*iDBSession); + scAddress = modemBearerRecord->iMessageCentreNumber; + + if (aSettings.DefaultServiceCenter() < 0 || !aSettings.ServiceCenterCount()) + { + compare(!scAddress.Length()); + } + else + { + compare(scAddress == aSettings.GetServiceCenter(aSettings.DefaultServiceCenter()).Address()); + } + + TUint32 valPeriod = 0; + valPeriod = modemBearerRecord->iMessageValidityPeriod; + compare(valPeriod == (TUint32) aSettings.ValidityPeriod().Int()); + + TBool delReport = EFalse; + delReport = modemBearerRecord->iMessageDeliveryReport; + compare(delReport ? aSettings.DeliveryReport() : !aSettings.DeliveryReport()); + CleanupStack::PopAndDestroy(modemBearerRecord); + delete iDBSession; + iDBSession = NULL; + return compare; + } + +TBool CSmutTest::CompareSettingsAndSmsBearerL(const CSmsSettings& aSettings) const + { + TUint32 smsBearer; + CMDBSession* iDBSession = CMDBSession::NewL(CMDBSession::LatestVersion()); + CMDBRecordSet globalSettingsRecord(KCDTIdGlobalSettingsRecord); + TRAPD(err, globalSettingsRecord.LoadL(*iDBSession)); + if(err != KErrNone) + { + User::Leave(KErrNotFound); + } + smsBearer = ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer; + delete iDBSession; + iDBSession = NULL; + TCompare compare(smsBearer == (TUint32) aSettings.SmsBearer()); + return compare; + } + +void CSmutTest::StoreNumberL(const CSmsNumber& aNumber, TUid aStreamId) + { + CMsvStore* store = iSmsTest.EditStoreL(); // lets edit the entry + CleanupStack::PushL(store); + + RMsvWriteStream out; + out.AssignLC(*store, aStreamId); // file stream id ok? + aNumber.ExternalizeL(out); // lets extrenalise the instance + out.CommitL(); + store->CommitL(); + + CleanupStack::PopAndDestroy(2); // out, store + } + +void CSmutTest::RestoreNumberL(CSmsNumber& rNumber, TUid aStreamId) + { + CMsvStore* store = iSmsTest.ReadStoreL(); // prepare the store for reading + CleanupStack::PushL(store); + + RMsvReadStream in; + in.OpenLC(*store, aStreamId); // lets open the store for + rNumber.InternalizeL(in); // internalising the address/name + + CleanupStack::PopAndDestroy(2); // in, store + } + +void CSmutTest::StoreHeaderL(const CSmsHeader& aHeader) + { + CMsvStore* store = iSmsTest.EditStoreL(); + CleanupStack::PushL(store); + + aHeader.StoreL(*store); + store->CommitL(); + + CleanupStack::PopAndDestroy(store); + } + +void CSmutTest::RestoreHeaderL(CSmsHeader& aHeader) + { + CMsvStore* store = iSmsTest.ReadStoreL(); + CleanupStack::PushL(store); + + aHeader.RestoreL(*store); + + CleanupStack::PopAndDestroy(store); + } + +void CSmutTest::StoreSettingsL(const CSmsSettings& aSettings) + { + + CSmsAccount* smsAccount = CSmsAccount::NewLC(); + smsAccount->SaveSettingsL(aSettings); + CleanupStack::PopAndDestroy(smsAccount); + + } + +void CSmutTest::RestoreSettingsL(CSmsSettings& aSettings) + { + + CSmsAccount* smsAccount = CSmsAccount::NewLC(); + smsAccount->LoadSettingsL(aSettings); + CleanupStack::PopAndDestroy(smsAccount); + + } + +TBool CSmutTest::CompareServiceCenters(const CSmsServiceCenter& aLeft, const CSmsServiceCenter& aRight) + { + TCompare compare(aLeft.Name() == aRight.Name()); + compare(aLeft.Address() == aRight.Address()); + + return compare; + } + +TBool CSmutTest::CompareNumbers(const CSmsNumber& aLeft, const CSmsNumber& aRight) + { + TCompare compare(aLeft.Name() == aRight.Name()); + compare(aLeft.Address() == aRight.Address()); + compare(aLeft.LogId() == aRight.LogId()); + + return compare; + } + +void CSmutTest::TestNumberL() + { + iSmsTest.Test().Next(_L("Testing CSmsNumber")); + iSmsTest.Printf(_L("Preparing test CSmsNumber")); + + TMsvId id=iSmsTest.CreateDummyMessageToSendL(); + Session().CleanupEntryPushL(id); + iSmsTest.SetEntryL(id); + + CSmsNumber* number0=CSmsNumber::NewL(); + CleanupStack::PushL(number0); + + CSmsNumber* number=CSmsNumber::NewL(); // create the instance + CleanupStack::PushL(number); + + // Testing the features of CSmsNumber + // The max length for a name is 256 characters + // The max length for a number is 20 characters + + +// Lets take an ordinary number, test it, then store and restore it +// and see if the values are still ok. + + number->SetNameL(_L("Radiolinja1")); // set the name + number->SetAddressL(_L("+358508771010")); // set the address + + iSmsTest(number->Name()==_L("Radiolinja1")); // name ok? + iSmsTest(number->Address()==_L("+358508771010")); // number ok? + + StoreNumberL(*number); + RestoreNumberL(*number0); + iSmsTest(CompareNumbers(*number0, *number)); + +// Lets try the max length of the telephone address, store and +// restore it and see if it works + + number->SetNameL(_L("Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?")); + number->SetAddressL(_L("+0123456789012345678")); + iSmsTest(number->Name()==_L("Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?Whatsthemaximumlengthforthis?")); + iSmsTest(number->Address()==_L("+0123456789012345678")); + + StoreNumberL(*number); + RestoreNumberL(*number0); + iSmsTest(CompareNumbers(*number, *number0)); + +// Lets use special Scandinavian letters both in the name and +// address, store and restore and see if they are ok + number->SetNameL(_L("ÖÄÅåöä")); + number->SetAddressL(_L("åäöÅÄÖ")); + iSmsTest(number->Name()==_L("ÖÄÅåöä")); + iSmsTest(number->Address()==_L("åäöÅÄÖ")); + + StoreNumberL(*number); + RestoreNumberL(*number0); + iSmsTest(CompareNumbers(*number, *number0)); + +// Lets try if both the number and the name can be empty, +// store and restore it and see if they still match + number->SetNameL(_L("")); + number->SetAddressL(_L("")); + iSmsTest(number->Name()==_L("")); + iSmsTest(number->Address()==_L("")); + + StoreNumberL(*number); + RestoreNumberL(*number0); + iSmsTest(CompareNumbers(*number, *number0)); + +// Lets try [alt+255] as both the name and number, store and +// restore it and see if it works + number->SetNameL(_L(" ")); //alt+255 + number->SetAddressL(_L(" ")); + iSmsTest(number->Name()==_L(" ")); + iSmsTest(number->Address()==_L(" ")); + + StoreNumberL(*number); + RestoreNumberL(*number0); + iSmsTest(CompareNumbers(*number, *number0)); + + CleanupStack::PopAndDestroy(2); //number, number0 + + //Test for defect EDNMOHN-4LDDK8 + number=CSmsNumber::NewL(); // create the instance + CleanupStack::PushL(number); + + StoreNumberL(*number); + RestoreNumberL(*number); + + number->SetAddressL(_L("+4477676545")); + //End Test for defect EDNMOHN-4LDDK8 + + CleanupStack::PopAndDestroy(2); //number, id + } + +void CSmutTest::TestHeaderL() + { + +// Testing class CSmsHeader + iSmsTest.Test().Next(_L("Testing CSmsHeader")); + +// A CSmsHeader can be of 6 different types +// First we test constructing ESmsDeliver + delete iSmsHeader; // deleting the previous one + iSmsHeader = NULL; + iSmsHeader=CSmsHeader::NewL(CSmsPDU::ESmsDeliver,*iRichText); // constructing + iSmsTest(iSmsHeader->Type()==CSmsPDU::ESmsDeliver); // type ok? + + CSmsDeliver& deliver = iSmsHeader->Deliver(); // lets get the CSmsPDU of the CSmsHeader + const CSmsDeliver& deliver2 = iSmsHeader->Deliver(); + + iSmsTest(deliver.Type() == CSmsPDU::ESmsDeliver); // Are the types ok? + iSmsTest(deliver2.Type() == CSmsPDU::ESmsDeliver); + +// Type ESmsCommand + delete iSmsHeader; // deleting previous + iSmsHeader=CSmsHeader::NewL(CSmsPDU::ESmsCommand,*iRichText); + iSmsTest(iSmsHeader->Type()==CSmsPDU::ESmsCommand); + + CSmsCommand& command=iSmsHeader->Command(); + const CSmsCommand& command2=iSmsHeader->Command(); + + iSmsTest(command.Type() == CSmsPDU::ESmsCommand); + iSmsTest(command2.Type() == CSmsPDU::ESmsCommand); + +// Type ESmsStatusReport + delete iSmsHeader; // deleting the previous one + iSmsHeader=CSmsHeader::NewL(CSmsPDU::ESmsStatusReport,*iRichText); + iSmsTest(iSmsHeader->Type()==CSmsPDU::ESmsStatusReport); + + CSmsStatusReport& statusreport=iSmsHeader->StatusReport(); + const CSmsStatusReport& statusreport2=iSmsHeader->StatusReport(); + + iSmsTest(statusreport.Type() == CSmsPDU::ESmsStatusReport); + iSmsTest(statusreport2.Type() == CSmsPDU::ESmsStatusReport); + +// Type ESmsSubmit + delete iSmsHeader; // deleting the previous one + iSmsHeader=CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText); + iSmsTest(iSmsHeader->Type()==CSmsPDU::ESmsSubmit); + + CSmsSubmit& submit=iSmsHeader->Submit(); + const CSmsSubmit& submit2=iSmsHeader->Submit(); + + iSmsTest(submit.Type() == CSmsPDU::ESmsSubmit); + iSmsTest(submit2.Type() == CSmsPDU::ESmsSubmit); + +// Lets access the CSmsMessage of our header + CSmsMessage& message=iSmsHeader->Message(); + const CSmsMessage& message2=iSmsHeader->Message(); + + iSmsTest(message.Type() == CSmsPDU::ESmsSubmit); + iSmsTest(message2.Type() == CSmsPDU::ESmsSubmit); + +// Lets test the features of CSmsHeader with different values + iSmsHeader->SetReplyPathProvided(ETrue); + iSmsTest(iSmsHeader->ReplyPathProvided()); + iSmsHeader->SetReplyPathProvided(EFalse); + iSmsTest(!iSmsHeader->ReplyPathProvided()); + + iSmsHeader->SetBioMsgIdType(EBioMsgIdUnknown); + iSmsTest(iSmsHeader->BioMsgIdType()==EBioMsgIdUnknown); + iSmsHeader->SetBioMsgIdType(EBioMsgIdIana); + iSmsTest(iSmsHeader->BioMsgIdType()==EBioMsgIdIana); + iSmsHeader->SetBioMsgIdType(EBioMsgIdNbs); + iSmsTest(iSmsHeader->BioMsgIdType()==EBioMsgIdNbs); + iSmsHeader->SetBioMsgIdType(EBioMsgIdWap); + iSmsTest(iSmsHeader->BioMsgIdType()==EBioMsgIdWap); + iSmsHeader->SetBioMsgIdType(EBioMsgIdWapSecure); + iSmsTest(iSmsHeader->BioMsgIdType()==EBioMsgIdWapSecure); + +// Lets set the service center number + iSmsHeader->SetServiceCenterAddressL(_L("+350508771010")); + iSmsTest(iSmsHeader->ServiceCenterAddress()==_L("+350508771010")); + +// Lets set one recipient for the message + CArrayPtrFlat& recipients = iSmsHeader->Recipients(); + CSmsNumber* number=CSmsNumber::NewL(); + CleanupStack::PushL(number); + number->SetAddressL(_L("+358503367709")); + recipients.AppendL(number); + CleanupStack::Pop(); + +// Setting settings of the message + CSmsSettings* smsset = CSmsSettings::NewL(); + CleanupStack::PushL(smsset); + smsset->AddServiceCenterL(_L("Hippo"), _L("+358508771010")); + smsset->SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit); + smsset->SetDelivery(ESmsDeliveryImmediately); + smsset->SetDeliveryReport(EFalse); + smsset->SetMessageConversion(ESmsConvPIDNone); + smsset->SetRejectDuplicate(ETrue); + smsset->SetReplyPath(EFalse); + smsset->SetValidityPeriod(ESmsVP24Hours); + smsset->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFSemiOctet); +// And copying them to the CSmsHeader + iSmsHeader->SetSmsSettingsL(*smsset); + CleanupStack::PopAndDestroy(smsset); + + CSmsSettings* smsset2 = CSmsSettings::NewL(); + CleanupStack::PushL(smsset2); +// Lets get the same setting from the CSmsHeader + iSmsHeader->GetSmsSettingsL(*smsset2); +// And compare that they are ok! + iSmsTest(smsset2->CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet7Bit); + iSmsTest(!smsset2->DeliveryReport()); + iSmsTest(smsset2->MessageConversion()==ESmsConvPIDNone); + iSmsTest(smsset2->RejectDuplicate()); + iSmsTest(!smsset2->ReplyPath()); + iSmsTest(smsset2->ValidityPeriod().Int()==ESmsVP24Hours); + iSmsTest(smsset2->ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFSemiOctet); + CleanupStack::PopAndDestroy(smsset2); + +//Test Set/FromAddress() + iSmsHeader->SetFromAddressL(_L("+358503367709")); + iSmsTest(iSmsHeader->FromAddress()==_L("+358503367709")); + +//Lets store and restore the CSmsHeader and test that the values are right + TMsvId id = iSmsTest.CreateDummyMessageToSendL(); + Session().CleanupEntryPushL(id); + iSmsTest.SetEntryL(id); + + StoreHeaderL(*iSmsHeader); + + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText); + CleanupStack::PushL(header); + + RestoreHeaderL(*header); + +//Values ok? + iSmsTest(iSmsHeader->Type()==header->Type()); + iSmsTest(!header->ReplyPathProvided()); + iSmsTest(header->ServiceCenterAddress()==_L("+350508771010")); + iSmsTest(iSmsHeader->Recipients().Count()==header->Recipients().Count()); + iSmsTest(iSmsHeader->BioMsgIdType()==header->BioMsgIdType()); + iSmsTest(iSmsHeader->FromAddress()==header->FromAddress()); + +// Lets get the setting of the message + CSmsSettings* smsset3 = CSmsSettings::NewL(); + CleanupStack::PushL(smsset3); + header->GetSmsSettingsL(*smsset3); + +// And compare that they are the original values + iSmsTest(smsset3->CharacterSet()==TSmsDataCodingScheme::ESmsAlphabet7Bit); + iSmsTest(!smsset3->DeliveryReport()); + iSmsTest(smsset3->MessageConversion()==ESmsConvPIDNone); + iSmsTest(smsset3->RejectDuplicate()); + iSmsTest(!smsset3->ReplyPath()); + iSmsTest(smsset3->ValidityPeriod().Int()==ESmsVP24Hours); + iSmsTest(smsset3->ValidityPeriodFormat()==TSmsFirstOctet::ESmsVPFSemiOctet); + + CleanupStack::PopAndDestroy(); // smsset3 + CleanupStack::PopAndDestroy(); // header + CleanupStack::PopAndDestroy(); // id + } + +_LIT(KGetDescriptionTestMessage, "Finland to win the ice hockey world champs"); + +void CSmutTest::TestSmsUtilitiesL() + { + iSmsTest.Test().Next(_L("Testing TSmsUtilities")); + + iRichText->Reset(); + iRichText->InsertL(0, KGetDescriptionTestMessage); + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText); + CleanupStack::PushL(header); + + TestSmsUtilities1L(*header); + TestSmsUtilities2L(*header); + TestSmsUtilities3L(*header); + + CleanupStack::PopAndDestroy(); //header + } + +void CSmutTest::TestSmsUtilities1L(CSmsHeader& aHeader) + { + iSmsTest.Printf(_L("Testing TSmsUtilities::GetDescription()")); + +//Test GetDescription() + + TPtrC buf(KGetDescriptionTestMessage); + TBuf desc; + TSmsUtilities::GetDescription(aHeader.Message(), desc); + iSmsTest(desc.Length()); + iSmsTest(desc == buf.Left( Min(buf.Length(), desc.Length()) ) ); //this won't work if buf contains CEditableText::EParagraphDelimiter + +//Test Special Message Indication + + CSmsPDU& pdu = aHeader.Message().SmsPDU(); + CSmsUserData& userData = pdu.UserData(); + TBuf8<2> msgInd; + msgInd.Copy(_L("AA")); + + iSmsTest.Printf(_L("\tAdding 1st information element (Fax) to UD\n")); + msgInd[0] = TSmsUtilities::EFaxMessageWaiting; + msgInd[1] = 0x00000001; //1 message + userData.AddInformationElementL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, msgInd); + TSmsUtilities::GetDescription(aHeader.Message(), desc); + iSmsTest.Printf(_L("\tGetDescription() returned: %S\n"), &desc); + iSmsTest(desc.Length()); + + //Add another information element + msgInd[0] = TSmsUtilities::EEmailMessageWaiting; + msgInd[1] = 0x00000001; //1 message + + iSmsTest.Printf(_L("\tAdding 2nd information element (Email) to UD\n")); + userData.AddInformationElementL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, msgInd); + TSmsUtilities::GetDescription(aHeader.Message(), desc); + iSmsTest.Printf(_L("\tGetDescription() returned: %S\n"), &desc); + iSmsTest(desc.Length()); + + iSmsTest.Printf(_L("Passed\n")); + } + +_LIT(KGetDetailsResult, "\t\tNum In: \"%S\" Name Out: \"%S\"\n"); + +void CSmutTest::TestSmsUtilities2L(CSmsHeader& aHeader) + { +//Test GetDetails + + iSmsTest.Printf(_L("Test TSmsUtilities::GetDetails()\n")); + + _LIT(KMikkoTel, "+358503367709"); + _LIT(KMikkoFirst, "Mikko"); + _LIT(KMikkoLast, "Rintala"); + _LIT(KMikkoEmail, "mikko@nokia.com"); + +// _LIT(KAnthonyTel, " + 4 "); //is valid + _LIT(KAnthonyTel, "+ 7 "); //is valid + _LIT(KAnthonyFirst, "Anthony"); + _LIT(KAnthonyLast, "Alexander"); + _LIT(KAnthonyEmail, "test@symbian.com"); + + _LIT(KHarriTel, "+8"); //is valid + _LIT(KHarriFirst, "HarriHarriHarriHarriHarriHarriHarri"); + _LIT(KHarriLast, "RäisänenRäisänenRäisänenRäisänenRäisänen"); + _LIT(KHarriEmail, "harri@nokia.com"); + + _LIT(KDupTel, "+44207435676"); + _LIT(KDupFirst1, "Keval"); + _LIT(KDupLast1, "Pindoria"); + _LIT(KDupFirst2, "Jackie"); + _LIT(KDupLast2, "Chan"); + + _LIT(KBadTel1, "This is a bad Telephone"); + _LIT(KBadTel2, " 5 "); + _LIT(KBadTel3, "5+"); + _LIT(KBadTel4, "*5565434556"); + + _LIT(KBadFirst, "BadFirstName"); + _LIT(KBadLast, "BadLastName"); + + _LIT(KNoNameTel, "+449005434"); + + _LIT(KDummy, "+44444"); + + TRAPD(err, iSmsTest.DeleteContactsFileL()); + iSmsTest(err == KErrNotFound || err == KErrNone); + + iSmsTest.Printf(_L("\tTesting without contacts\n")); + + //Simple test + TPtrC testTel(KMikkoTel); + TBuf details; + + aHeader.Message().SetToFromAddressL(testTel); + TSmsUtilities::GetDetails(iSmsTest.FileSession(), aHeader.Message(), details); + iSmsTest.Printf(KGetDetailsResult, &testTel, &details); + iSmsTest(testTel.FindF(details) != KErrNotFound); + + TestInvalidTelOrContact(testTel, details); + + testTel.Set(KAnthonyTel); + aHeader.Message().SetToFromAddressL(testTel); + err = TSmsUtilities::GetDetails(iSmsTest.FileSession(), aHeader.Message(), details); + iSmsTest.Printf(KGetDetailsResult, &testTel, &details); + iSmsTest(testTel.FindF(details) != KErrNotFound); + iSmsTest(err == KErrNone); + + TestInvalidTelOrContact(testTel, details); + + //Add contacts + + iSmsTest.Printf(_L("\tAdding Contacts\n")); + + //Adding good telephone numbers + + TContactItemId contId = iSmsTest.CreateContactL(KAnthonyFirst, KAnthonyLast, KAnthonyTel, KAnthonyEmail); + iSmsTest(contId != KNullContactId); + + contId = iSmsTest.CreateContactL(KMikkoFirst, KMikkoLast, KMikkoTel, KMikkoEmail); + iSmsTest(contId != KNullContactId); + + contId = iSmsTest.CreateContactL(KHarriFirst, KHarriLast, KHarriTel, KHarriEmail); + iSmsTest(contId != KNullContactId); + + //Adding a duplicate telephone + + contId = iSmsTest.CreateContactL(KDupFirst1, KDupLast1, KDupTel, KNullDesC); + iSmsTest(contId != KNullContactId); + + contId = iSmsTest.CreateContactL(KDupFirst2, KDupLast2, KDupTel, KNullDesC); + iSmsTest(contId != KNullContactId); + + //Adding bad telephone numbers + + contId = iSmsTest.CreateContactL(KBadFirst, KBadLast, KBadTel1, KNullDesC); + iSmsTest(contId != KNullContactId); + + contId = iSmsTest.CreateContactL(KBadFirst, KBadLast, KBadTel2, KNullDesC); + iSmsTest(contId != KNullContactId); + + contId = iSmsTest.CreateContactL(KBadFirst, KBadLast, KBadTel3, KNullDesC); + iSmsTest(contId != KNullContactId); + + contId = iSmsTest.CreateContactL(KBadFirst, KBadLast, KBadTel4, KNullDesC); + iSmsTest(contId != KNullContactId); + + //Adding no name contact + + contId = iSmsTest.CreateContactL(KNullDesC, KNullDesC, KNoNameTel, KNullDesC); + iSmsTest(contId != KNullContactId); + + iSmsTest.Printf(_L("\tTesting with valid telephone numbers\n")); + + TestValidTel(KAnthonyTel, KAnthonyFirst, KAnthonyLast, KNullDesC, details); + TestValidTel(KMikkoTel, KMikkoFirst, KMikkoLast, KNullDesC, details); + TestValidTel(KHarriTel, _L("Räisänen"), KNullDesC, _L("Harri"), details); + + iSmsTest.Printf(_L("\tTesting with invalid telephone numbers\n")); + + TestInvalidTelOrContact(KBadTel1, details); + TestInvalidTelOrContact(KBadTel2, details); + TestInvalidTelOrContact(KBadTel3, details); + TestInvalidTelOrContact(KBadTel4, details); + + iSmsTest.Printf(_L("\tTesting with duplicate telephone numbers\n")); + +// TestInvalidTelOrContact(KDupTel, details); //Fails because of CntModel defect EDNAALR-4Q2L4D + + iSmsTest.Printf(_L("\tTesting No Names telephone number\n")); + + TestInvalidTelOrContact(KNoNameTel, details); + TestInvalidTelOrContact(KDummy, details); + + iSmsTest.Printf(_L("Passed\n")); + } + +void CSmutTest::TestValidTel(const TDesC& aTel, const TDesC& aExpect1, const TDesC& aExpect2, const TDesC& aNotExpect, TDes& rDetails) + { + TInt err = TSmsUtilities::GetDetails(iSmsTest.FileSession(), aTel, rDetails); + iSmsTest.Printf(KGetDetailsResult, &aTel, &rDetails); + + if (aExpect1.Length()) + iSmsTest(rDetails.FindF(aExpect1) != KErrNotFound); + + if (aExpect2.Length()) + iSmsTest(rDetails.FindF(aExpect2) != KErrNotFound); + + if (aNotExpect.Length()) + iSmsTest(rDetails.FindF(aNotExpect) == KErrNotFound); + + iSmsTest(err == KErrNone); + } + +void CSmutTest::TestInvalidTelOrContact(const TDesC& aTel, TDes& rDetails) + { + TInt err = TSmsUtilities::GetDetails(iSmsTest.FileSession(), aTel, rDetails); + iSmsTest.Printf(KGetDetailsResult, &aTel, &rDetails); + iSmsTest(aTel.FindF(rDetails) != KErrNotFound); + iSmsTest(err == KErrNone); + } + +void CSmutTest::TestSmsUtilities3L(CSmsHeader& aHeader) + { + iSmsTest.Printf(_L("Test TSmsUtilities::ServiceIdL()\n")); + + TMsvId id2 = KMsvNullIndexEntryId; +// First tested function is ServiceIdL() + TSmsUtilities::ServiceIdL(*iSmsTest.iMsvEntry, id2); + iSmsTest(id2 == iSmsTest.iSmsServiceId); + iSmsTest.Printf(_L("\tPassed\n")); + + iSmsTest.Printf(_L("Test TSmsUtilities::PopulateMsgEntry()\n")); + TMsvEntry entry; + TSmsUtilities::PopulateMsgEntry(entry,aHeader.Message(), iSmsTest.iSmsServiceId); +//To Do: More tests + iSmsTest.Printf(_L("\tPassed\n")); + }