// Copyright (c) 2008-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 The TEFUnit test suite for SmsControl in the Common TSY.

*/

#include "cctsysmsfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <test/tmockltsydata.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/ltsy/mltsydispatchphoneinterface.h>

#include <ctsy/ltsy/mltsydispatchsmsinterface.h>

#include "cctsyactiveretriever.h"

#include <mmretrieve.h>

#include "mockltsyindicatorids.h"

CTestSuite* CCTsySmsFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

    //add use-case tests	

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUseCase0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUseCase0002L);

    //add other unit tests

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0006L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0007L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0008L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0009L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsFU, TestUnit0010L);	

	END_SUITE;

	}

LOCAL_C void FillInSmsParams(

		TSmsParameters& aSmsParams1,

		TSmsParameters& aSmsParams2)

	{

	aSmsParams1.iLocationNumber = 1;

	aSmsParams1.iParameterIndicator = KDestinationAddress|KServiceCentreAddress;

	aSmsParams1.iProtocolId = 2;

	aSmsParams1.iDataCodingScheme = 3;

	aSmsParams1.iValidityPeriod = 4;

	aSmsParams1.iMobileScTON = RMobilePhone::EInternationalNumber;

	aSmsParams1.iMobileScNPI = RMobilePhone::EIsdnNumberPlan;

	aSmsParams1.iMobileDeTON = RMobilePhone::ENationalNumber;

	aSmsParams1.iMobileDeNPI = RMobilePhone::EDataNumberPlan;

	aSmsParams1.iAlphaTagPresent = ETrue;

	aSmsParams1.iServiceCenterAddress.Copy(_L("asta"));

	aSmsParams1.iDestinationAddress.Copy(_L("la"));

	aSmsParams1.iAlphaTagData.Copy(_L("vista"));

	aSmsParams2.iLocationNumber = 5;

	aSmsParams2.iParameterIndicator = KProtocolID|KDataCodingScheme|KValidityPeriod;

	aSmsParams2.iProtocolId = 6;

	aSmsParams2.iDataCodingScheme = 7;

	aSmsParams2.iValidityPeriod = 8;

	aSmsParams2.iMobileScTON = RMobilePhone::ENetworkSpecificNumber;

	aSmsParams2.iMobileScNPI = RMobilePhone::ETelexNumberPlan;

	aSmsParams2.iMobileDeTON = RMobilePhone::ESubscriberNumber;

	aSmsParams2.iMobileDeNPI = RMobilePhone::ENationalNumberPlan;

	aSmsParams2.iAlphaTagPresent = EFalse;

	aSmsParams2.iServiceCenterAddress.Copy(_L("I'l"));

	aSmsParams2.iDestinationAddress.Copy(_L("be"));

	aSmsParams2.iAlphaTagData.Copy(_L("back"));

	}

//

// Use-case tests

//

/**

@SYMTestCaseID BA-CTSYD-DIS-SMS-UC0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for ReceiveMessage()

@SYMTestPriority High

@SYMTestActions Invokes ReceiveMessage()

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySmsFU::TestUseCase0001L()

	{

    OpenEtelServerL(EUseExtendedError);

    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    OpenPhoneL();

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    RBuf8 data;

    CleanupClosePushL(data);

    TRequestStatus reqStatus;

    TRequestStatus mockLtsyStatus;

    RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;

    RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);

    _LIT8(KMessage, "Happy New Year");

    TBuf8<100> forMsg;

    // receiving message:

    messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);

    TSmsMsg smsMsg;

    TSmsMsg* smsMsgPtr(&smsMsg);

    TBool ind(EFalse);

    smsMsg.iSmsClass2 = ETrue;

    smsMsg.iDeleteAfterClientAck = ETrue;

    smsMsg.iSmsMsg.Copy(KMessage);

    TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(KMockLtsyDispatchSmsNotifyReceiveSmsMessageIndId, KErrNone, data);

    User::WaitForRequest(reqStatus);    

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    AssertMockLtsyStatusL();

    TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);

    TInt rpCause(0);

    TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);

    data.Close();

    expTsyData.SerialiseL(data);

    iMockLTSY.ExpectL(MLtsyDispatchSmsNackSmsStored::KLtsyDispatchSmsNackSmsStoredApiId, data);

    iMockLTSY.CompleteL(MLtsyDispatchSmsNackSmsStored::KLtsyDispatchSmsNackSmsStoredApiId, KErrNone);

    messaging.NackSmsStored(reqStatus, KMessage, rpCause); 

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNone, reqStatus.Int());   

    AssertMockLtsyStatusL();  

    // receiving message:

    messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(KMockLtsyDispatchSmsNotifyReceiveSmsMessageIndId, KErrNone, data);

    User::WaitForRequest(reqStatus);    

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    AssertMockLtsyStatusL();    

    TDesC8* msgPtr2 = const_cast<TDesC8*>(&KMessage);

    TMockLtsyData1<TDesC8*> expTsyData2(msgPtr2);

    data.Close();

    expTsyData2.SerialiseL(data);

    iMockLTSY.ExpectL(MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId, data);

    iMockLTSY.CompleteL(MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId, KErrNone);

    // acknowledgment message receive:

    messaging.AckSmsStored(reqStatus, KMessage, ETrue);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    AssertMockLtsyStatusL();

    // receiving message:

    messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);

    data.Close();

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(KMockLtsyDispatchSmsNotifyReceiveSmsMessageIndId, KErrNone, data);

    TDesC8* msgPtr3 = NULL;

    TMockLtsyData1<TDesC8*> expTsyData3(msgPtr3);

    data.Close();

    expTsyData3.SerialiseL(data);

    iMockLTSY.ExpectL(MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId, data);

    User::WaitForRequest(reqStatus);    

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    AssertMockLtsyStatusL();

    CleanupStack::PopAndDestroy(3, this);    

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SMS-UC0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for successful RMobileSmsMessaging::SendMessage

@SYMTestPriority High

@SYMTestActions Invokes RMobileSmsMessaging::SendMessage

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySmsFU::TestUseCase0002L()

	{

    OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    _LIT8(KMessage, "Hello");

    TBuf8<32> tmpName(KMessage);

    TRequestStatus reqStatus;

    RMobileSmsMessaging::TMobileSmsSendAttributesV1 expectSmsAttr;

    RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;

    RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);

    TSendSmsDataAndAttributes dataAndAttr;

    dataAndAttr.iIpc = EMobileSmsMessagingSendMessage; 

    dataAndAttr.iAttributes = &expectSmsAttr;

    dataAndAttr.iMsgData = &tmpName; 

    TDesC8* msgPtr = dataAndAttr.iMsgData;        

    TMockLtsyData5< RMobilePhone::TMobileAddress, 

                        TDesC8*,

                        RMobileSmsMessaging::TMobileSmsDataFormat,

                        RMobilePhone::TMobileAddress,

                        TBool

                       > expTsyData(smsAttr.iDestination, msgPtr, smsAttr.iDataFormat, smsAttr.iGsmServiceCentre, smsAttr.iMore);

    _LIT8(KSubmit, "Submit");

    _LIT(KNum, "+7903030303");

    smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;

    smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

    smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);

    smsAttr.iCdmaServiceCategory = 0;

    smsAttr.iCdmaTeleservice = 0;

    smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

    smsAttr.iFlags = 0;

    smsAttr.iMsgRef = 0;

    smsAttr.iSubmitReport = KSubmit;

    smsAttr.iMore = EFalse;

    smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;

    smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

    smsAttr.iDestination.iTelNumber.Copy(KNum);

    expectSmsAttr = smsAttr;        

    expTsyData.SerialiseL(data);    

    iMockLTSY.ExpectL(MLtsyDispatchSmsSendSmsMessage::KLtsyDispatchSmsSendSmsMessageApiId, data);

    data.Close();

    const TInt16 KMsgRef(25);

    TInt16 msgRef(KMsgRef);

    TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);

    TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);    

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchSmsSendSmsMessage::KLtsyDispatchSmsSendSmsMessageApiId, KErrNone, data, 10);

    data.Close();

    /*

     * The fields required will probably be message data format, destination 

     * and possibly a new service centre  address. 

     * On return, for either successful or failed transmission, the message reference number assigned to this 

     * sent message will be placed by the TSY in the iMsgRef field. 

     * Also, if the SMS was sent during GSM or WCDMA mode, then 

     * the SMS-SUBMIT-REPORT will be placed by the TSY in the iSubmitReport field.

     *  

     */    

    messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);

    ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);

    ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));

    ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);

    ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);

    ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);           

    ASSERT_TRUE((RMobileSmsMessaging::KMessageReference | RMobileSmsMessaging::KGsmSubmitReport)

                        == smsAttr.iFlags);

    ASSERT_TRUE(msgRef == smsAttr.iMsgRef);

    ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(smsMsg));

    ASSERT_TRUE(EFalse == smsAttr.iMore);

    ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);

    ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);

    ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3, this); 

	}

//

// Other unit tests

//

/**

@SYMTestCaseID BA-CTSYD-DIS-SMS-UN0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::AckSmsStored()

@SYMTestPriority High

@SYMTestActions Invokes AckSmsStored()

@SYMTestExpectedResults Pass

@SYMTestType UT

 */

void CCTsySmsFU::TestUnit0001L()

	{	

    OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);	

	RBuf8 data;

	CleanupClosePushL(data);	

	_LIT8(KMessage, "Happy New Year");

    TRequestStatus reqStatus;

    TRequestStatus mockLtsyStatus;    

    TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);

    TMockLtsyData1<TDesC8*> expTsyData(msgPtr);

    //-------------------------------------------------------------------------

    // TEST B: failure on completion of pending request from LTSY->CTSY

    //-------------------------------------------------------------------------

    RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;

    RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);

    TBuf8<100> forMsg;

    // receiving message:

    messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);

    TSmsMsg smsMsg;

    TSmsMsg* smsMsgPtr(&smsMsg);

    TBool ind(EFalse);

    smsMsg.iSmsClass2 = ETrue;

    smsMsg.iDeleteAfterClientAck = ETrue;

    smsMsg.iSmsMsg.Copy(KMessage);

    TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(KMockLtsyDispatchSmsNotifyReceiveSmsMessageIndId, KErrNone, data);

    User::WaitForRequest(reqStatus);    

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    AssertMockLtsyStatusL();

    expTsyData.SerialiseL(data);  

    iMockLTSY.ExpectL(MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId, data);

    iMockLTSY.CompleteL(MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId, KErrGeneral);

    messaging.AckSmsStored(reqStatus, KMessage, ETrue);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

    AssertMockLtsyStatusL();

    //-------------------------------------------------------------------------

    // TEST C1, check AckSmsStored() when there is no sms received

    //-------------------------------------------------------------------------

    messaging.AckSmsStored(reqStatus, KMessage, ETrue);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNotReady, reqStatus.Int());

    AssertMockLtsyStatusL(); 

    //-------------------------------------------------------------------------

    // TEST E: Unsolicited completion of RMobileSmsMessaging::AckSmsStored

    // from LTSY.

    //-------------------------------------------------------------------------

    iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(MLtsyDispatchSmsAckSmsStored::KLtsyDispatchSmsAckSmsStoredApiId, KErrNone);

    User::WaitForRequest(mockLtsyStatus);

    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3, this); // data, messaging, this	

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SMS-UN0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetMessageStoreInfo()

@SYMTestPriority High

@SYMTestActions Invokes GetMessageStoreInfo()

@SYMTestExpectedResults Pass

@SYMTestType UT

 */

void CCTsySmsFU::TestUnit0002L()

	{	

    OpenEtelServerL(EUseExtendedError);

    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    OpenPhoneL();

    RBuf8 data;

    CleanupClosePushL(data);

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    TRequestStatus reqStatus;

    RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;

    RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);

    TInt index(0);

    //-------------------------------------------------------------------------

    // TEST A: failure to dispatch request to LTSY

    //-------------------------------------------------------------------------

    iMockLTSY.ExpectL(MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId, KErrNotSupported);

    messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

    AssertMockLtsyStatusL();

    //-------------------------------------------------------------------------

    // TEST B: failure on completion of pending request from LTSY->CTSY

    //-------------------------------------------------------------------------

    iMockLTSY.ExpectL(MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId);

    messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);

    TInt total(0);

    TInt used(0);

    TMockLtsyData2<TInt, TInt> compData(total, used);

    compData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId, KErrGeneral, data);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

    AssertMockLtsyStatusL();

    //-------------------------------------------------------------------------

    // TEST C: Successful completion request of

    // RMobileSmsMessaging::GetMessageStoreInfo when result is not cached.

    //-------------------------------------------------------------------------

    iMockLTSY.ExpectL(MLtsyDispatchSmsGetSmsStoreInfo::KLtsyDispatchSmsGetSmsStoreInfoApiId);

    messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);

    total = 2;

    used = 1;

    data.Close();