// Copyright (c) 1997-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:

// Tests the Sms functionality of the Basic MMTsy.

// 

//

/**

 @file

*/

#include "Te_Sms.h"		

const TInt KOneSecond = 1000000;

CTestSendSms::CTestSendSms() 

	{

	SetTestStepName(_L("TestSendSms"));

	}

enum TVerdict CTestSendSms::doTestStepL()

	{

	SendSms();

	return EPass;

	}

CTestAckSmsStored::CTestAckSmsStored() 

	{

	SetTestStepName(_L("TestAckSmsStored"));

	}

enum TVerdict CTestAckSmsStored::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

	TRequestStatus status;

	TBuf8<400> buf;

	TBuf8<400> *NULLbuf =NULL;

	// Create a PDU

	RMobilePhone::TMobileAddress addr;

	addr.iTypeOfNumber=RMobilePhone::EInternationalNumber;

	addr.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

	addr.iTelNumber.Copy(_L("44 7785 016 005"));

	buf.Zero();	

	AppendAddressToAscii(buf,addr);

	iSms.AckSmsStored(status, buf);

	User::WaitForRequest(status);

	if(status.Int() == KErrNotSupported)

		{

		iSms.AckSmsStored(status, *NULLbuf);

		User::WaitForRequest(status);

		TESTL(status.Int() == KErrNotSupported);

		}

	return TestStepResult();

	}

CTestAckSmsStoredCancel::CTestAckSmsStoredCancel() 

	{

	SetTestStepName(_L("TestAckSmsStoredCancel"));

	}

enum TVerdict CTestAckSmsStoredCancel::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.AckSmsStoredCancel();		// This API doesn't exist anymore

	return EPass;

	}

CTestNackSmsStored::CTestNackSmsStored() 

	{

	SetTestStepName(_L("TestNackSmsStored"));

	}

enum TVerdict CTestNackSmsStored::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

	TRequestStatus status;

	TBuf8<400> buf;

	// Create a PDU

	RMobilePhone::TMobileAddress addr;

	addr.iTypeOfNumber=RMobilePhone::EInternationalNumber;

	addr.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

	addr.iTelNumber.Copy(_L("44 7785 016 005"));

	buf.Zero();	

	AppendAddressToAscii(buf,addr);

	iSms.NackSmsStored(status, buf, KErrGsmRRInvalidMessage);

	User::WaitForRequest(status);

	TEST(status.Int() == KErrNotSupported);

	return TestStepResult();

	}

CTestNackSmsStoredCancel::CTestNackSmsStoredCancel() 

	{

	SetTestStepName(_L("TestNackSmsStoredCancel"));

	}

enum TVerdict CTestNackSmsStoredCancel::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.NackSmsStoredCancel();		// API doesn't exist anymore

	return EPass;

	}

CTestAckSmsStoredWithResponse::CTestAckSmsStoredWithResponse() 

	{

	SetTestStepName(_L("TestAckSmsStoredWithResponse"));

	}

enum TVerdict CTestAckSmsStoredWithResponse::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.AckSmsStoredWithResponse();	// API doesn't exist anymore

	return EPass;

	}

CTestAckSmsStoredWithResponseCancel::CTestAckSmsStoredWithResponseCancel() 

	{

	SetTestStepName(_L("TestAckSmsStoredWithResponseCancel"));

	}

enum TVerdict CTestAckSmsStoredWithResponseCancel::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.AckSmsStoredWithResponseCancel();		// API doesn't exist anymore

	return EPass;

	}

CTestNackSmsStoredWithResponse::CTestNackSmsStoredWithResponse() 

	{

	SetTestStepName(_L("TestNackSmsStoredWithResponse"));

	}

enum TVerdict CTestNackSmsStoredWithResponse::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.NackSmsStoredWithResponse();		// API doesn't exist anymore

	return EPass;

	}

CTestNackSmsStoredWithResponseCancel::CTestNackSmsStoredWithResponseCancel() 

	{

	SetTestStepName(_L("TestNackSmsStoredWithResponseCancel"));

	}

enum TVerdict CTestNackSmsStoredWithResponseCancel::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.NackSmsStoredWithResponseCancel();		// API doesn't exist anymore

	return EPass;

	}

CTestResumeSmsReception::CTestResumeSmsReception() 

	{

	SetTestStepName(_L("TestResumeSmsReception"));

	}

enum TVerdict CTestResumeSmsReception::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

	TRequestStatus status;

	iSms.ResumeSmsReception(status);

	User::WaitForRequest(status);

	TESTL(status.Int() == KErrNotSupported);

	return TestStepResult();

	}

CTestNotifySmsEvent::CTestNotifySmsEvent() 

	{

	SetTestStepName(_L("TestNotifySmsEvent"));

	}

enum TVerdict CTestNotifySmsEvent::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.NotifySmsEvent();		// API doesn't exist anymore

	return EPass;

	}

CTestNotifySmsEventCancel::CTestNotifySmsEventCancel() 

	{

	SetTestStepName(_L("TestNotifySmsEventCancel"));

	}

enum TVerdict CTestNotifySmsEventCancel::doTestStepL()

/**

 * This function Tests an API that should return

 * KErrNotSupported

 */

	{

//	iSms.NotifySmsEventCancel();	// API doesn't exist anymore

	return EPass;

	}

CTestGetCaps::CTestGetCaps() 

	{

	SetTestStepName(_L("TestGetCaps"));

	}

enum TVerdict CTestGetCaps::doTestStepL()

/**

 * This function tests the capabilities API of the Messaging subssession.

 */

	{

	INFO_PRINTF1(_L("Get Capabilities."));

	RMobileSmsMessaging::TMobileSmsCapsV1Pckg smsCapsPckg(iSmsCaps);

	INFO_PRINTF1(_L(".."));

	TESTL(iSms.GetCaps(smsCapsPckg)==KErrNone);

	INFO_PRINTF1(_L("test(s) passed"));

	return TestStepResult();

	}

CTestSmspList::CTestSmspList() 

	{

	SetTestStepName(_L("TestSmspList"));

	}

enum TVerdict CTestSmspList::doTestStepL()

/**

 * This function tests get/set service centre address

 */

	{

	INFO_PRINTF1(_L("Check TSY's SMSP capabilities.."));

	if ((iSmsCaps.iSmsControl & RMobileSmsMessaging::KCapsGetSmspList) &&

	    (iSmsCaps.iSmsControl & RMobileSmsMessaging::KCapsSetSmspList))

		{

		INFO_PRINTF1(_L("Caps - KCapsGetSmspList supported"));

		INFO_PRINTF1(_L("Caps - KCapsSetSmspList supported"));

		RMobileSmsMessaging::TMobileSmspEntryV1 defaultSmspEntry;

		RMobileSmsMessaging::TMobileSmspEntryV1 newSmspEntry;

		RMobileSmsMessaging::TMobileSmspEntryV1 checkSmspEntry;

		INFO_PRINTF1(_L("Retrieve default SMSP list"));

		TRAPD(ret, GetSmspListL(defaultSmspEntry));

		TESTL(ret == KErrNone);

		INFO_PRINTF1(_L("Store new SMSP list"));

		newSmspEntry.iValidParams = RMobileSmsMessaging::KSCAIncluded;

		newSmspEntry.iServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;

		newSmspEntry.iServiceCentre.iNumberPlan=RMobilePhone:: EIsdnNumberPlan;

		newSmspEntry.iServiceCentre.iTelNumber.Copy(_L("01632960000"));

		TRAP(ret, SetSmspListL(newSmspEntry));

		TESTL(ret == KErrNone);

		INFO_PRINTF1(_L("Check SMSP list contains new entry"));

		TRAP(ret, GetSmspListL(checkSmspEntry));

		TESTL(ret == KErrNone);

		INFO_PRINTF1(_L("Rewrite default SMSP list"));

		TRAP(ret, SetSmspListL(defaultSmspEntry));

		TESTL(ret == KErrNone);

		INFO_PRINTF1(_L("Check SMSP list contains default entry"));

		TRAP(ret, GetSmspListL(checkSmspEntry));

		TESTL(ret == KErrNone);

		}

	return TestStepResult();

	}

CTestMessageStoreInfo::CTestMessageStoreInfo() 

	{

	SetTestStepName(_L("TestMessageStoreInfo"));

	}

enum TVerdict CTestMessageStoreInfo::doTestStepL()

/**

 * This function retrieves the number of message stores supported by the iPhone. It

 * also gets the details of the supported message stores. It then gets and sets the

 * Default Service Center Address (SCA) and performs some Cancel Requests.

 */

	{	

	INFO_PRINTF1(_L("Test RMobileSmsMessaging::EnumerateMessageStores.."));

	TInt ret=KErrNone;

	TInt count=0;

	TInt i;

	ret=iSms.EnumerateMessageStores(count);

	TEST_CHECKL(ret, KErrNone, _L("Error retrieving message store count")); 

	INFO_PRINTF2(_L("There are %d SMS message stores"), count);

	INFO_PRINTF1(_L("Test RMobileSmsMessaging::GetMessageStoreInfo...")); 

	TRequestStatus reqStatus;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 smsInfo;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg smsInfoPckg(smsInfo);

	for (i=0; i<count; i++)

		{

		iSms.GetMessageStoreInfo(reqStatus, i, smsInfoPckg);

		User::WaitForRequest(reqStatus);

		TESTL(reqStatus==KErrNone);

		TEST(smsInfo.iType==RMobilePhoneStore::EShortMessageStore);

		// Print the result

		INFO_PRINTF1(_L("Information retrieved about the message store"));

		INFO_PRINTF2(_L("Name					 : %S"), &smsInfo.iName);

		INFO_PRINTF2(_L("Total number of entries  : %d"), smsInfo.iTotalEntries);

		INFO_PRINTF2(_L("Number of used entries   : %d"), smsInfo.iUsedEntries);

		INFO_PRINTF2(_L("Capabilities(in hex)	 : %X"), smsInfo.iCaps);

		PrintMessageStoreCaps(smsInfo.iCaps);

		User::After(10000000);		// Give user time to see the test results 

		}

	// Test immediate cancelling of request

	if (count>0)

		{

		INFO_PRINTF1(_L("Test cancelling of GetMessageStoreInfo request"));

		iSms.GetMessageStoreInfo(reqStatus, 0, smsInfoPckg);

		iSms.CancelAsyncRequest(EMobileSmsMessagingGetMessageStoreInfo);

		User::WaitForRequest(reqStatus);

		if (reqStatus==KErrCancel)

			INFO_PRINTF1(_L("Request successfully cancelled"));

		else if (reqStatus==KErrNone)

			INFO_PRINTF1(_L("Request completed before it could be cancelled"));

		else

			{

			INFO_PRINTF2(_L("Request failed with: %d"), reqStatus.Int());

			SetTestStepResult(EFail);

			}		

		}

	// Test delayed cancelling of request

	if (count>1)

		{

		INFO_PRINTF1(_L("Test cancelling of GetMessageStoreInfo request..."));

		iSms.GetMessageStoreInfo(reqStatus, 1, smsInfoPckg);

	//	User::After(500000);	

		iSms.CancelAsyncRequest(EMobileSmsMessagingGetMessageStoreInfo);

		User::WaitForRequest(reqStatus);

		TEST(reqStatus==KErrCancel || reqStatus==KErrNone);

		if (reqStatus==KErrCancel)

			INFO_PRINTF1(_L("Request successfully cancelled"));

		else

			INFO_PRINTF1(_L("Request completed before it could be cancelled"));

		}

	return TestStepResult();

	}

CTestMessageStoreOps::CTestMessageStoreOps() 

	{

	SetTestStepName(_L("TestMessageStoreOps"));

	}

enum TVerdict CTestMessageStoreOps::doTestStepL()

/**

 * This function performs Message Store Operations.

 * It opens the SIM and ME Stores, writes & reads sms' to these stores, performs

 * appropriate Cancel operations and gets information on the SIM and ME stores.

 */

	{

	// Test open message store and get info

	RMobileSmsStore simStore;

	// Nokia 9210 doesn't support ME SMS storage. 

	// This flag is used to skip the related tests.

	TBool meSupported;

	TInt ret=simStore.Open(iSms, KETelIccSmsStore);

	TESTL(ret==KErrNone);

	CleanupClosePushL(simStore);

	INFO_PRINTF1(_L("SIM message store opened..."));

	TRequestStatus reqStatus;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 simSmsInfo;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg simSmsInfoPckg(simSmsInfo);

	INFO_PRINTF1(_L("Retrieving SIM message store info..."));

	simStore.GetInfo(reqStatus, simSmsInfoPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus==KErrNone);

	if (reqStatus!=KErrNone)

		INFO_PRINTF2(_L("Error %d retrieving SIM message store info"), ret); 

	else

		{

		TEST(simSmsInfo.iType==RMobilePhoneStore::EShortMessageStore);

		// Print the result

		INFO_PRINTF1(_L("Information retrieved about the message store"));

		INFO_PRINTF2(_L("Name					 : %S"), &simSmsInfo.iName);

		INFO_PRINTF2(_L("Total number of entries  : %d"), simSmsInfo.iTotalEntries);

		INFO_PRINTF2(_L("Number of used entries   : %d"), simSmsInfo.iUsedEntries);

		INFO_PRINTF2(_L("Capabilities(in hex)	 : %X"), simSmsInfo.iCaps);

		PrintMessageStoreCaps(simSmsInfo.iCaps);

		User::After(10000000);		// Give user time to see the test results 

		}

	// Test immediate cancelling of request

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 simSmsInfo2;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg simSmsInfoPckg2(simSmsInfo2);

	INFO_PRINTF1(_L("Test immediate cancelling of GetInfo request..."));

	simStore.GetInfo(reqStatus, simSmsInfoPckg2);

	simStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus==KErrCancel || reqStatus==KErrNone);

	if (reqStatus==KErrCancel)

		INFO_PRINTF1(_L("Request successfully cancelled"));

	else

		INFO_PRINTF1(_L("Request completed before it could be cancelled"));

	// Test delayed cancelling of request

	INFO_PRINTF1(_L("Test delayed cancelling of GetInfo request"));

	simStore.GetInfo(reqStatus, simSmsInfoPckg2);

	User::After(500000);	

	simStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus==KErrCancel || reqStatus==KErrNone);

	if (reqStatus==KErrCancel)

		INFO_PRINTF1(_L("Request successfully cancelled"));

	else

		INFO_PRINTF1(_L("Request completed before it could be cancelled"));

	// Test the same information retrieval for ME SMS store

	RMobileSmsStore meStore;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 meSmsInfo;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg meSmsInfoPckg(meSmsInfo);

	ret=meStore.Open(iSms, KETelMeSmsStore);

	TESTL(ret==KErrNone);

	CleanupClosePushL(meStore);

	INFO_PRINTF1(_L("ME message store opened."));

	INFO_PRINTF1(_L("Retrieving ME message store info..."));

	meStore.GetInfo(reqStatus, meSmsInfoPckg);

	User::WaitForRequest(reqStatus);

	if (reqStatus!=KErrNone)

		{

		INFO_PRINTF2(_L("Error %d retrieving ME message store info."), reqStatus.Int()); 

		INFO_PRINTF1(_L("*** Please retry test with another phone ***"));

		meSupported=FALSE;

		if(TestStepResult() == EPass)

			SetTestStepResult(EInconclusive);

		}

	else

		{

		TEST(meSmsInfo.iType==RMobilePhoneStore::EShortMessageStore);

		// Print the result

		INFO_PRINTF1(_L("Information retrieved about the message store"));

		INFO_PRINTF2(_L("Name					 : %S"), &meSmsInfo.iName);

		INFO_PRINTF2(_L("Total number of entries  : %d"), meSmsInfo.iTotalEntries);

		INFO_PRINTF2(_L("Number of used entries   : %d"), meSmsInfo.iUsedEntries);

		INFO_PRINTF2(_L("Capabilities(in hex)	 : %X"), meSmsInfo.iCaps);

		PrintMessageStoreCaps(meSmsInfo.iCaps);

		User::After(10000000);		// Give user time to see the test results 

		meSupported=TRUE;

		}

	// Test immediate cancelling of request

	if (meSupported==TRUE)

		{

		RMobilePhoneStore::TMobilePhoneStoreInfoV1 meSmsInfo2;

		RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg meSmsInfoPckg2(meSmsInfo2);

		INFO_PRINTF1(_L("Test immediate cancelling of GetInfo request..."));

		meStore.GetInfo(reqStatus, meSmsInfoPckg2);

		meStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);

		User::WaitForRequest(reqStatus);

		TEST(reqStatus==KErrCancel || reqStatus==KErrNone);

		if (reqStatus==KErrCancel)

			INFO_PRINTF1(_L("Request successfully cancelled"));

		else

			INFO_PRINTF1(_L("Request completed before it could be cancelled"));

		// Test delayed cancelling of request

		INFO_PRINTF1(_L("Test delayed cancelling of GetInfo request"));

		meStore.GetInfo(reqStatus, meSmsInfoPckg2);

		User::After(500000);	

		meStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);

		User::WaitForRequest(reqStatus);

		TEST(reqStatus==KErrCancel || reqStatus==KErrNone);

		if (reqStatus==KErrCancel)

			INFO_PRINTF1(_L("Request successfully cancelled"));

		else

			INFO_PRINTF1(_L("Request completed before it could be cancelled"));

		}

	// Test reading all the messages in SIM store

	// Print details of each message

	INFO_PRINTF1(_L("Reading Messages from SIM Store..."));

	RMobileSmsStore::TMobileGsmSmsEntryV1 smsEntry;

	RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsEntryPckg(smsEntry);

	for (TInt i=1; i<=simSmsInfo.iUsedEntries; i++)

		{

		smsEntry.iIndex=i;		// Entry to read

		simStore.Read(reqStatus, smsEntryPckg);

		User::WaitForRequest(reqStatus);

		TESTL(reqStatus==KErrNone || reqStatus==KErrNotFound);

		if (reqStatus == KErrNotFound)

			INFO_PRINTF2((_L("The entry was not found, request status = %d")), reqStatus.Int());

		else