// 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_smut.h"

#include <smss.rsg>

#include <etelmm.h>

#include <smutset.h>

#include <csmsaccount.h>

#include <csmsemailfields.h>

#include <csmsgetdetdescinterface.h>

const TUid KUidMsvSmsEmailFieldsStream	= {0x10204C9D};

GLDEF_C TInt E32Main()

	{	

	__UHEAP_MARK;

	test.Start(_L("Setup"));

	theCleanup = CTrapCleanup::New();

	TRAPD(ret,doMainL());		

	test(ret==KErrNone);

	delete theCleanup;	

	test.Console()->SetPos(0, 13);

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(KErrNone);

	}

LOCAL_C void doMainL()

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test);

	CleanupStack::PushL(smsTest);

	TInt nextTest = 0;

	CSmutTest* SmcmTest = CSmutTest::NewLC(*smsTest, KNullDesC, nextTest);

	SmcmTest->StartL();

	CleanupStack::PopAndDestroy(3, scheduler);

	}

CSmutTest::CSmutTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)

: CSmsTestBase(aSmsTest, aScriptFile, aNextTest)

	{

	}

void CSmutTest::RunAutoL()

	{

	iNextTest = 0;

	// Testing TMsvSmsEntry

	iSmsTest.TestStart(++iNextTest, _L("TMsvSmsEntry"));

	TestSmsEntryL();

	iSmsTest.TestFinish(iNextTest);

	// 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 email fields class (CSmsEmailFields)

	iSmsTest.TestStart(++iNextTest, _L("CSmsEmailFields"));  

	TestEmailFieldsL();

	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();

	// Testing with ECOM Plugin class (CSmsGetDetDescInterface)

	iSmsTest.TestStart(++iNextTest, _L("CSmsGetDetDescInterface"));

	TestSmsUtilitiesBL();

	iSmsTest.TestFinish(iNextTest);

	iSmsTest.TestStart(++iNextTest, _L("EMS Extensions"));

	TestSmsEmsExtensionsL();

	iSmsTest.TestFinish(iNextTest);

	}

CSmutTest::~CSmutTest()

	{

	delete iSmsHeader;

	delete iRichText;

	delete iParaLayer;

	delete iCharLayer;

	delete iDBSession;

	}

void CSmutTest::ConstructL()

	{

	iSmsTest.SetLogToFile();

	iSelection = new (ELeave) CMsvEntrySelection();

	iTimer = CTestTimer::NewL();

	iParaLayer =CParaFormatLayer::NewL();

	iCharLayer = CCharFormatLayer::NewL();

	iRichText = CRichText::NewL(iParaLayer, iCharLayer, CEditableText::EFlatStorage,256);

	iDBSession = CMDBSession::NewL(CMDBSession::LatestVersion());	

	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"));

	iSmsTest.AppendToMenuL(_L("Sms Utilities"));

	iSmsTest.AppendToMenuL(_L("Sms Settings"));

	TInt result = iSmsTest.DisplayMenu(_L("SMS Client MTM Test"));

	if (result <= 0)

		return;

	switch (result)

		{

		case 1:

			RunAutoL();

			break;

		case 2:

			TestSmsUtilitiesL();

			break;

		case 3:

			TestSettingsL();

			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

	TestStoreRestoreSettingsL(*settings);

// 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);

	TestStoreRestoreSettingsL(*set2);

	set2->SetClass2Folder(123);

	TestStoreRestoreSettingsL(*set2);

	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"));

	}

TBool CSmutTest::CompareSettingsFiles(

	RFs& aFs, const TDesC& aCompare1, const TDesC& aCompare2

	)

	{

	TBool identical = ETrue;

	RFileReadStream stream1;

	RFileReadStream stream2;

	// Open each stream for binary read.

	stream1.Open(aFs, aCompare1, EFileStream | EFileRead);

	stream2.Open(aFs, aCompare2, EFileStream | EFileRead);

	TInt ret1 = KErrNone;

	TInt ret2 = KErrNone;

	TBool finished = EFalse;

	TUint8 byte1 = 0;

	TUint8 byte2 = 0;

	while (!finished)

		{

		TRAP(ret1, byte1 = stream1.ReadUint8L());

		TRAP(ret2, byte2 = stream2.ReadUint8L());

		if (byte1 != byte2 || ret1 == KErrEof || ret2 == KErrEof)

			{

			// Either file data or lengths differ.

			if ((byte1 != byte2) || (ret1 != ret2))

				identical = EFalse;

			finished = ETrue;

			}

		}

	stream1.Close();

	stream2.Close();

	return identical;

	}

void CSmutTest::TestStoreRestoreSettingsL(const CSmsSettings& aSettings)

	{

	StoreSettingsL(aSettings);

// Lets read the service and see it the values are still ok

	CSmsSettings* set1=CSmsSettings::NewL();

	CleanupStack::PushL(set1);

	RestoreSettingsL(*set1);

	iSmsTest(CompareSettings(*set1, aSettings));

	CleanupStack::PopAndDestroy(set1);

	}

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);

	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

	aSettings.SetStatusReportHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EMoveReportToInboxVisibleAndMatch);

	aSettings.SetStatusReportHandling(CSmsSettings::EDiscardReportAndMatch);

	iSmsTest(aSettings.StatusReportHandling()==CSmsSettings::EDiscardReportAndMatch);

	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);

	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxInvisibleAndMatch);

	aSettings.SetSpecialMessageHandling(CSmsSettings::EMoveReportToInboxVisibleAndMatch);

	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EMoveReportToInboxVisibleAndMatch);

	aSettings.SetSpecialMessageHandling(CSmsSettings::EDiscardReportAndMatch);

	iSmsTest(aSettings.SpecialMessageHandling()==CSmsSettings::EDiscardReportAndMatch);

	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"));

// Class2Folder

	iSmsTest(aSettings.Class2Folder() == KMsvGlobalInBoxIndexEntryId);

	aSettings.SetClass2Folder(1);

	iSmsTest(aSettings.Class2Folder() == 1);

	iSmsTest.Printf(_L("Test Class2Folder Passed\n"));	

// Description length

	iSmsTest(aSettings.DescriptionLength() == KSmsDescriptionLength);

	aSettings.SetDescriptionLength(100);

	iSmsTest(aSettings.DescriptionLength() == 100);

	iSmsTest.Printf(_L("Test DescriptionLength 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);