// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// The TEFUnit test suite for SmsMessaging in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsysmsmessagingfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

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

    {

    SUB_SUITE;

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyMoSmsBearerChange0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMoSmsBearer0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetReceiveMode0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0001AL);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestEnumerateMessageStores0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetCaps0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetCaps0003L);

    END_SUITE;

    }

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-SMSM-SNMSBC-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifyMoSmsBearerChange

@SYMTestPriority High

@SYMTestActions Invokes RMobileSmsMessaging::NotifyMoSmsBearerChange

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsySmsMessagingFU::TestNotifyMoSmsBearerChange0001L()

    {

    OpenEtelServerL(EUseExtendedError);

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

    OpenPhoneL();

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    RMobileSmsMessaging::TMobileSmsBearer smsBearer;

    TRequestStatus reqStatus;

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

    // TEST A: failure to dispatch request to LTSY

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

    messaging.NotifyMoSmsBearerChange(reqStatus, smsBearer);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

    AssertMockLtsyStatusL();

    CleanupStack::PopAndDestroy(2, this); 

    }

/**

@SYMTestCaseID BA-CTSY-SMSM-SNRMC-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifyReceiveModeChange

@SYMTestPriority High

@SYMTestActions Invokes RMobileSmsMessaging::NotifyReceiveModeChange

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0001L()

    {

    OpenEtelServerL(EUseExtendedError);

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

    OpenPhoneL();

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;

    RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);

    TRequestStatus reqStatus;

    TRequestStatus reqSetStatus;

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

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

    // from LTSY.

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

    messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

    User::WaitForRequest(reqSetStatus);

    ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

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

    // TEST C: Successful completion request of

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

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

    messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);

    messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

    User::WaitForRequest(reqSetStatus);

    ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode);

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

    // TEST E2: Unsolicited completion of RMobileSmsMessaging::NotifyReceiveModeChange

    // from LTSY.

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

    //Request for EMobileSmsMessagingNotifyReceiveModeChange is self reposting. 

    //If it was completed somehow and then SetReceiveMode() was called without call of NotifyReceiveModeChange() - 

    //this result in getting wrong request handle for completion in CTelObject::ReqCompleted() 

    //{updatedReqEntry=PhoneOwner()->FindByTsyHandleAndPlacedRequest(aTsyReqHandle);

    //__ASSERT_ALWAYS(updatedReqEntry!=NULL, Fault(EEtelFaultCompletionReceivedWithNoReqPackage));}

    messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

    User::WaitForRequest(reqSetStatus);

    ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

    AssertMockLtsyStatusL();

    CleanupStack::PopAndDestroy(2, this); // data, this

    }

/**

@SYMTestCaseID BA-CTSY-SMSM-SNRMC-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::NotifyReceiveModeChange

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RMobileSmsMessaging::NotifyReceiveModeChange

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0002L()

    {

    OpenEtelServerL(EUseExtendedError);

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

    OpenPhoneL();

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;

    RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);

    TRequestStatus reqStatus;

    TRequestStatus reqSetStatus;

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

    // Test cancelling of RMobileSmsMessaging::NotifyReceiveModeChange

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

    messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);

    messaging.CancelAsyncRequest(EMobileSmsMessagingNotifyReceiveModeChange);

    messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

    User::WaitForRequest(reqSetStatus);

    ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrCancel, reqStatus.Int());

    CleanupStack::PopAndDestroy(2);

    }

/**

@SYMTestCaseID BA-CTSY-SMSM-SNRMC-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::NotifyReceiveModeChange

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::NotifyReceiveModeChange

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0004L()

    {

    OpenEtelServerL(EUseExtendedError);

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

    OpenPhoneL();

    // Open second client

    RTelServer telServer2;

    TInt ret = telServer2.Connect();

    ASSERT_EQUALS(KErrNone, ret);

    CleanupClosePushL(telServer2);

    RMobilePhone phone2;

    ret = phone2.Open(telServer2,KMmTsyPhoneName);

    ASSERT_EQUALS(KErrNone, ret);

    CleanupClosePushL(phone2);

    RMobileSmsMessaging messaging;

    TInt err = messaging.Open(iPhone);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging);

    RMobileSmsMessaging messaging2;

    err = messaging2.Open(phone2);

    ASSERT_EQUALS(KErrNone, err);

    CleanupClosePushL(messaging2);

    RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;

    RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);

    TRequestStatus reqStatus;

    TRequestStatus reqSetStatus;

    RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode2;

    TRequestStatus reqStatus2;

    TRequestStatus reqSetStatus2;

    messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);

    messaging2.NotifyReceiveModeChange(reqStatus2, smsReceiveMode2);

    messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

    User::WaitForRequest(reqSetStatus);

    ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNone, reqStatus.Int());

    User::WaitForRequest(reqStatus2);

    ASSERT_EQUALS(KErrNone, reqStatus2.Int());

    ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode);

    ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode2);

    CleanupStack::PopAndDestroy(5, this); 

    }

/**

@SYMTestCaseID BA-CTSY-SMSM-SSM-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage

@SYMTestPriority High

@SYMTestActions Invokes RMobileSmsMessaging::SendMessage

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsySmsMessagingFU::TestSendMessage0001L()

    {

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

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

    // TEST A: failure to dispatch request to LTSY

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

    _LIT8(KMessage, "Merry christmas");

    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; 

    TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);           

    expTsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data, KErrNotSupported);

    messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

    AssertMockLtsyStatusL();

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

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

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

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

    const TInt16 KMsgRef(25);

    TInt16 msgRef(KMsgRef);

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

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

    data.Close();

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

    messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

    data.Close();

    expTsyData.SerialiseL(data);

    // complete request by error passing to HandleRequest() in ResendSms()

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data, KErrNotSupported);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

    AssertMockLtsyStatusL();

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

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

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

    // the API makes 3 attemps to make the EMobileSmsMessagingSendMessage request

    // we complete all of them with KErrGeneral

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

    data.Close();

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

    messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

    data.Close();

    expTsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

    data.Close();

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

    data.Close();

    expTsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

    data.Close();

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

    AssertMockLtsyStatusL();

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

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

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

    TMockLtsyData1<TSendSmsDataAndAttributes> expData(dataAndAttr);           

    expData.SerialiseL(data);    

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

    data.Close();

    compTsyData.SerialiseL(data);  

    //simulate error code sent by network when SMS msg has an invalid destination number

    TInt compErrorCode = -298123266;

    iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, compErrorCode, data, 10);

    messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(KErrGsmSMSNetworkOutOfOrder, reqStatus.Int());

    AssertMockLtsyStatusL();

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

    // TEST C: Successful completion request of

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

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

    _LIT8(KSubmit, "Submit");

    _LIT(KNum, "+441632960000");

    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;

    data.Close();

    expTsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

    data.Close();

    compTsyData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);

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