diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simatktsy/tests/src/ccsatsetupeventlistfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simatktsy/tests/src/ccsatsetupeventlistfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2174 @@ +// 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 SetUpEventList in the SAT. +*/ + +#include "ccsatsetupeventlistfu.h" +#include // Etel SAT IPC definitions +#include +#include + + +static const TUint8 KDelay = 10; + +static const TUint8 KPcmdNumber = 1; +//channel 1, Link established or Packet data service activated +static const TUint8 KChannelStatusByte1 = 0x81; + +static const TInt KSubAddressLength = 100; + +// these constants are used to show that they are NOT supported by TSY +static const TUint8 KDisplayParamsChanges_missing = 0x0C; +static const TUint8 KLocalConnection_missing = 0x0D; + +//ETLV_CommandNumber +static const TUint8 KTestCommandNumber = 0x01; +//ETLV_CommandQualifier +static const TUint8 KTestCommandQualifier = 0x00; + + + +CTestSuite* CCSatSetUpEventListFU::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001L); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001bL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001cL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001dL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001eL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001fL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001gL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001hL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001iL); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0001jL); + + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0002L); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestNotifySetUpEventListPCmd0004L); + ADD_TEST_STEP_ISO_CPP(CCSatSetUpEventListFU, TestEventDownload0001L); + + END_SUITE; + } + + +// +// Actual test cases +// + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpEventListPCmd +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001L() + { + static const TUint8 events[] = {KEventUserActivity}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RSat::NotifySetUpEventListPCmd + //------------------------------------------------------------------------- + + // see TestNotifySetUpEventListPCmd0001bL - TestNotifySetUpEventListPCmd0001kL + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RSat::NotifySetUpEventListPCmd + // from LTSY. + //------------------------------------------------------------------------- + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + const TDesC8& tlv = eventTlv.End(); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(tlv, KErrNone); + + // as TerminalResponse is called from CTSY + // Prepare here ExpectL for it + TBuf8<1> resultAddInfo; + resultAddInfo.Append(RSat::KNoSpecificMeProblem); + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KMeUnableToProcessCmd, resultAddInfo); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + // post Complete with KErrUnknown, the request must be left pending + CompleteMockDispatchSatPcmdL(tlv, KErrUnknown); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // post next Complete with KErrNone to complete request successfully + CompleteMockDispatchSatPcmdL(tlv, KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1, this); // this + + } + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0002 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for cancelling of RSat::NotifySetUpEventListPCmd +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0002L() + { + static const TUint8 events[] = {KEventUserActivity}; + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + //------------------------------------------------------------------------- + // Test cancelling of RSat::NotifySetUpEventListPCmd + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + TRequestStatus requestStatus; + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + // cancel Notify + iSat.CancelAsyncRequest(ESatNotifySetUpEventListPCmd); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + // Now post Complete after cancel + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + // as TerminalResponse is called from CTSY + // Prepare here ExpectL for it + TBuf8<1> resultAddInfo; + resultAddInfo.Append(RSat::KNoSpecificMeProblem); + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KMeUnableToProcessCmd, resultAddInfo); + + // wait for CompleteMockDispatchSatPcmdL + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0004 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for multiple client requests to RSat::NotifySetUpEventListPCmd +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0004L() + { + static const TUint8 events[] = {KEventUserActivity}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + // 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); + RSat sat2; + User::LeaveIfError(sat2.Open(phone2)); + CleanupClosePushL(sat2); + + TRequestStatus requestStatus; + TRequestStatus requestStatus2; + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post first Notify + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // Post second Notify + RSat::TSetUpEventListV1 eventList2; + RSat::TSetUpEventListV1Pckg eventListPck2(eventList2); + sat2.NotifySetUpEventListPCmd(requestStatus2, eventListPck2); + + // prepare TLV for the first client + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + + // post Complete for + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS((TUint)RSat::KUserActivity, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + ASSERT_EQUALS((TUint)RSat::KUserActivity, eventList2.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList2.iType); + + // ---TERMINAL RESPONSE from the first client--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + // ---ENVELOPE: EVENT DOWNLOAD from the first client--- + PrepareAndCallEventDownloadL(KEventUserActivity); + + // ---TERMINAL RESPONSE from the second client--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + sat2.TerminalRsp(requestStatus2, RSat::ESetUpEventList, respPckg); + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + AssertMockLtsyStatusL(); + // ---ENVELOPE: EVENT DOWNLOAD from the second client--- + PrepareAndCallEventDownloadL(KEventUserActivity, &sat2, EFalse, KErrNone); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // ..., this + } + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001b +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Expected Sequence 1.1 (SET UP EVENT LIST, User Activity) +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001bL() + { + static const TUint8 events[] = {KEventUserActivity}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + + //------------------------------------------------------------------------- + // Expected Sequence 1.1 (SET UP EVENT LIST, User Activity) + // see ETSI TS 102 384 V6.5.0 + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS((TUint)RSat::KUserActivity, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + // ---ENVELOPE: EVENT DOWNLOAD--- + PrepareAndCallEventDownloadL(KEventUserActivity); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001c +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test for KEventIdleScreenAvailable and KEventLanguageSelection events +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001cL() + { + static const TUint8 events[] = {KEventIdleScreenAvailable, KEventLanguageSelection}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + + //------------------------------------------------------------------------- + // Test for KEventIdleScreenAvailable and KEventLanguageSelection events + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + // create constant to compare with data got in NotifySetUpEventListPCmd + TUint eventsFlag = RSat::KIdleScreenAvailable + RSat::KLanguageSelection; // as we asked for KEventIdleScreenAvailable and KEventLanguageSelection + ASSERT_EQUALS(eventsFlag, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + // ---ENVELOPE: KEventLanguageSelection--- + PrepareAndCallEventDownloadL(KEventLanguageSelection); + // ---ENVELOPE: KEventIdleScreenAvailable--- + PrepareAndCallEventDownloadL(KEventIdleScreenAvailable); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001d +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test for KEventBrowserTermination, KEventDataAvailable and KEventChannelStatus events +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001dL() + { + static const TUint8 events[] = {KEventBrowserTermination, KEventDataAvailable, KEventChannelStatus}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + + //------------------------------------------------------------------------- + // Test for KEventBrowserTermination, KEventDataAvailable and KEventChannelStatus events + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + TUint eventsFlag = RSat::KBrowserTermination + RSat::KDataAvailable + RSat::KChannelStatus; + ASSERT_EQUALS(eventsFlag, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + // ---ENVELOPE: KEventBrowserTermination--- + PrepareAndCallEventDownloadL(KEventBrowserTermination); + // ---ENVELOPE: KEventDataAvailable--- + PrepareAndCallEventDownloadL(KEventDataAvailable); + // ---ENVELOPE: KEventChannelStatus--- + PrepareAndCallEventDownloadL(KEventChannelStatus); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001e +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test for KEventMTCall, KEventCallConnected, KEventCallDisconnected, KEventLocationStatus and KEventAccessTechnologyChange events +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001eL() + { + static const TUint8 eventListComplete[] = { KEventMTCall, + KEventCallConnected, + KEventCallDisconnected, + KEventLocationStatus, + KEventAccessTechnologyChange}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + + //------------------------------------------------------------------------- + // Test for KEventMTCall, KEventCallConnected, KEventCallDisconnected, KEventLocationStatus, + // and KEventAccessTechnologyChange events. TSY is responsible for these events + // and they shouldn't be reported to ETel + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, eventListComplete, sizeof(eventListComplete)/sizeof(TUint8)); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + // user receives empty event list + TUint eventsFlag = 0; + ASSERT_EQUALS(eventsFlag, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001f +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Tests for all possible flow of CSatNotifySetUpEventList::TerminalResponseL +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001fL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + // test all possible parameters for CSatNotifySendUssd::CreateTerminalRespL() + + DoTestTerminalResponseL(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1, this); //this + } + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001g +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test send ENVELOPE for events handled by TSY (just for coverage!) +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001gL() + { + static const TUint8 eventListComplete[] = { KEventMTCall, + KEventCallConnected, + KEventCallDisconnected, + KEventLocationStatus, + KEventAccessTechnologyChange}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + //------------------------------------------------------------------------- + // Test ENVELOPE for events handled by TSY: + //KEventMTCall, KEventCallConnected, KEventCallDisconnected, KEventLocationStatus, + //and KEventAccessTechnologyChange. + // (just for coverage!) + //------------------------------------------------------------------------- + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, eventListComplete, sizeof(eventListComplete)/sizeof(TUint8)); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS((TUint)0, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + // ENVELOPE for KEventMTCall + EnvelopeFromTsyL(KEventMTCall); + + // ENVELOPE for KEventCallConnected + EnvelopeFromTsyL(KEventCallConnected); + + // ENVELOPE for KEventCallDisconnected + EnvelopeFromTsyL(KEventCallDisconnected); + + // ENVELOPE for KEventLocationStatus + EnvelopeFromTsyL(KEventLocationStatus); + + // ENVELOPE for KEventAccessTechnologyChange + EnvelopeFromTsyL(KEventAccessTechnologyChange); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001h +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test send Unsolicited ENVELOPE for events handled by TSY (just for coverage!) +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001hL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + //------------------------------------------------------------------------- + // Test Unsolicited ENVELOPE for events handled by TSY: + //KEventMTCall, KEventCallConnected, KEventCallDisconnected, KEventLocationStatus, + //and KEventAccessTechnologyChange. + // (just for coverage!) + //------------------------------------------------------------------------- + + // Unsolicited ENVELOPE for KEventMTCall + EnvelopeFromTsyL(KEventMTCall, EFalse); + + // Unsolicited ENVELOPE for KEventCallConnected + EnvelopeFromTsyL(KEventCallConnected, EFalse); + + // Unsolicited ENVELOPE for KEventCallDisconnected + EnvelopeFromTsyL(KEventCallDisconnected, EFalse); + + // Unsolicited ENVELOPE for KEventLocationStatus + EnvelopeFromTsyL(KEventLocationStatus, EFalse); + + // Unsolicited ENVELOPE for KEventAccessTechnologyChange + EnvelopeFromTsyL(KEventAccessTechnologyChange, EFalse); + + // Unsolicited ENVELOPE for KEventUserActivity + EnvelopeFromTsyL(KEventUserActivity, EFalse); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001i +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test send Unsolicited ENVELOPE and failure to dispatch request to LTSY for events handled by ETEL (just for coverage!) +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001iL() + { + static const TUint8 events[] = {KEventUserActivity, + KEventIdleScreenAvailable, + KEventBrowserTermination, + KEventLanguageSelection, + KEventDataAvailable, + KEventChannelStatus}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + // ---ENVELOPE: KEventUserActivity --- + PrepareAndCallEventDownloadL(KEventUserActivity, NULL, ETrue, KErrNone); + + // ---ENVELOPE: KEventIdleScreenAvailable --- + PrepareAndCallEventDownloadL(KEventIdleScreenAvailable, NULL, ETrue, KErrNone); + + // ---ENVELOPE: KEventBrowserTermination --- + PrepareAndCallEventDownloadL(KEventBrowserTermination, NULL, ETrue, KErrNone); + + // ---ENVELOPE: KEventLanguageSelection --- + PrepareAndCallEventDownloadL(KEventLanguageSelection, NULL, ETrue, KErrNone); + + // ---ENVELOPE: KEventDataAvailable --- + PrepareAndCallEventDownloadL(KEventDataAvailable, NULL, ETrue, KErrNone); + + // ---ENVELOPE: KEventChannelStatus --- + PrepareAndCallEventDownloadL(KEventChannelStatus, NULL, ETrue, KErrNone); + + + //------------------------------------------------------------------------- + // Failure to dispatch request to LTSY + // Like "Test A" of 0001 tests for ENVELOPE command + //------------------------------------------------------------------------- + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + + TRequestStatus requestStatus; + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + TUint eventsFlag = RSat::KUserActivity + RSat::KIdleScreenAvailable + + RSat::KBrowserTermination + RSat::KLanguageSelection + + RSat::KDataAvailable + RSat::KChannelStatus; + ASSERT_EQUALS(eventsFlag, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + // ---ENVELOPE: KEventUserActivity--- + PrepareAndCallEventDownloadL(KEventUserActivity, NULL, EFalse, KErrUnknown); + + // ---ENVELOPE: KEventIdleScreenAvailable--- + PrepareAndCallEventDownloadL(KEventIdleScreenAvailable, NULL, EFalse, KErrUnknown); + + // ---ENVELOPE: KEventBrowserTermination--- + PrepareAndCallEventDownloadL(KEventBrowserTermination, NULL, EFalse, KErrUnknown); + + // ---ENVELOPE: KEventLanguageSelection--- + PrepareAndCallEventDownloadL(KEventLanguageSelection, NULL, EFalse, KErrUnknown); + + // ---ENVELOPE: KEventDataAvailable--- + PrepareAndCallEventDownloadL(KEventDataAvailable, NULL, EFalse, KErrUnknown); + + // ---ENVELOPE: KEventChannelStatus--- + PrepareAndCallEventDownloadL(KEventChannelStatus, NULL, EFalse, KErrUnknown); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1, this); //this + } + + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SNSUELPC-0001j +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Some tests for coverage of CSatNotifySetUpEventList::CompleteNotifyL() +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestNotifySetUpEventListPCmd0001jL() + { + static const TUint8 eventListComplete[] = {KEventUserActivity, KEventUserActivity}; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + TRequestStatus mockStatus; + + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + // Post Notify itself + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + + //------------------------------------------------------------------------- + //Pass TLV-buffer from LTSY to TSY without KTlvEventListTag tag + //------------------------------------------------------------------------- + TTlv eventTlv; + eventTlv.Begin(KBerTlvProactiveSimCommandTag); + eventTlv.AddTag(KTlvCommandDetailsTag); + eventTlv.AddByte(KTestCommandNumber);//ETLV_CommandNumber + eventTlv.AddByte(KSetUpEventList); //ETLV_TypeOfCommand + eventTlv.AddByte(KTestCommandQualifier); //ETLV_CommandQualifier + eventTlv.AddTag(KTlvDeviceIdentityTag); + eventTlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + eventTlv.AddByte(KMe); + + iMockLTSY.NotifyTerminated(mockStatus); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + // as TerminalResponse is called from CTSY (in this case) + // Prepare here ExpectL for it + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KErrorRequiredValuesMissing, KNullDesC8); + // wait for complete of iMockLTSY.NotifyTerminated(mockStatus) because TSY doesn't inform client + // about errors from LTSY + User::WaitForRequest(mockStatus); + ASSERT_EQUALS(KErrNone, mockStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + //Pass event from LTSY to TSY with invalid event code + //------------------------------------------------------------------------- + // prepare TLV with invalid event code + TUint8 wrongEventList[] = {0xFF}; + PrepareTlv( eventTlv, wrongEventList, sizeof(wrongEventList)/sizeof(TUint8)); + + iMockLTSY.NotifyTerminated(mockStatus); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + // as TerminalResponse is called from CTSY (in this case) + // Prepare here ExpectL for it + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KCmdBeyondMeCapabilities, KNullDesC8); + // wait for complete of iMockLTSY.NotifyTerminated(mockStatus) because TSY doesn't inform client + // about errors from LTSY + User::WaitForRequest(mockStatus); + ASSERT_EQUALS(KErrNone, mockStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + //Pass TLV-buffer from LTSY to TSY without EvenList (remove all events) + //------------------------------------------------------------------------- + PrepareTlv( eventTlv, NULL, 0); + eventTlv.AddTag(KTlvEventListTag); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS((TUint) 0, eventList.iEvents); + ASSERT_EQUALS(RSat::ERemoveExistingEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = RSat::KSuccess; + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + //Pass event list from LTSY to TSY with two identical events + //------------------------------------------------------------------------- + // Post Notify again + PrepareMockLDataWithExpL(KSetUpEventList); + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + // prepare TLV + PrepareTlv( eventTlv, eventListComplete, sizeof(eventListComplete)/sizeof(TUint8)); + + iMockLTSY.NotifyTerminated(mockStatus); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(eventTlv.End(), KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS((TUint) RSat::KUserActivity, eventList.iEvents); + ASSERT_EQUALS(RSat::EUpdateEventList, eventList.iType); + + // ---TERMINAL RESPONSE--- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8); + // call TerminalRsp + TerminalResponseL(respPckg); + AssertMockLtsyStatusL(); + + // ---ENVELOPE: EVENT DOWNLOAD--- + PrepareAndCallEventDownloadL(KEventUserActivity); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // this + } + + +/** +@SYMTestCaseID BA-CSAT-SUEL-SED-0001 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for RSat::EventDownload +@SYMTestPriority High +@SYMTestActions Invokes RSat::EventDownload +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSetUpEventListFU::TestEventDownload0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + TRequestStatus requestStatus; + + //------------------------------------------------------------------------- + // TEST Unsolicited call of RSat::EventDownload + // without getting notifications from CTSY + //------------------------------------------------------------------------- + RSat::TEventDownloadBaseV2 baseEventInfo; + RSat::TEventDownloadBaseV2Pckg baseEventInfoPckg(baseEventInfo); + iSat.EventDownload(requestStatus, RSat::KIdleScreenAvailable, baseEventInfoPckg); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()) + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1, this); // this + + // All other EventDownload tests are the part of NotifySetUpEventListPCmd tests + } + + +//---------------------------------------------------------------------------------------------------------- +// Utility functions +//---------------------------------------------------------------------------------------------------------- + +/** +* Prepare data for ExpectL() and post ExpectL. +* @param aPCmdNumber - code of Proactive SIM commands +*/ +void CCSatSetUpEventListFU::PrepareMockLDataWithExpL( TUint8 aCommand ) + { + TPckg pcmdCodePckg(aCommand); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, pcmdCodePckg); + } + +/** +* prepare tlv buffer +* @param aTlv - tlv buffer to prepare +* @param aEventList - List of codes of events +* @param aNumberOfEvents - number of events +*/ +void CCSatSetUpEventListFU::PrepareTlv(TTlv& aTlv, const TUint8* aEventList, TUint8 aNumberOfEvents) + { + aTlv.Begin(KBerTlvProactiveSimCommandTag); + aTlv.AddTag(KTlvCommandDetailsTag); + aTlv.AddByte(KTestCommandNumber);//ETLV_CommandNumber + aTlv.AddByte(KSetUpEventList); //ETLV_TypeOfCommand + aTlv.AddByte(KTestCommandQualifier); //ETLV_CommandQualifier + aTlv.AddTag(KTlvDeviceIdentityTag); + aTlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + aTlv.AddByte(KMe); + + if (0 < aNumberOfEvents) + { + aTlv.AddTag(KTlvEventListTag); + + for (TInt i = 0; i < aNumberOfEvents; i++) + { + aTlv.AddByte(aEventList[i]); + } + } + } + + +/** + * prepare mock for processing of proactive command + * @param aCompleteTlv - tlv buffer to send + * @param aError - result for request completion + */ +void CCSatSetUpEventListFU::CompleteMockDispatchSatPcmdL( TPtrC8 aCompleteTlv, TInt aError ) + { + RBuf8 data; + CleanupClosePushL(data); + + TDesC8* tlvPtr = &aCompleteTlv; + TMockLtsyData1 dspTxtDscPack(tlvPtr); + dspTxtDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, aError, data, KDelay); + + CleanupStack::PopAndDestroy(&data); + } + + + +/** + * prepare data and call iMockLTSY.ExpectL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, data); + * @param aPCmdNumber - command number + * @param aGeneralResult - result of terminal response + * @param aResultAddInfo - result's additional info + * @param aErrorForExpect - error, expected from LTSY + */ +void CCSatSetUpEventListFU::PrepareTerminalResponseMockDataWithExpL( + TUint8 aPCmdNumber, + RSat::TPCmdResult aGeneralResult, + const TDesC8& aResultAddInfo, + TInt aErrorForExpect) + { + RBuf8 data; + CleanupClosePushL(data); + + RBuf8 terminalRsp; + CleanupClosePushL(terminalRsp); + terminalRsp.CreateL(KTlvMaxSize); + + TTlv tlv; + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(aPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KSetUpEventList); //ETLV_TypeOfCommand + tlv.AddByte(KTestCommandQualifier); //ETLV_CommandQualifier 0x00 -- according to Test requirement + + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KMe); + tlv.AddByte(KSim); + + tlv.AddTag(KTlvResultTag); + tlv.AddByte(aGeneralResult); + if (aResultAddInfo.Length()) + { + tlv.AddByte( ( TUint8 ) aResultAddInfo[0] ); + } + + terminalRsp.Append(tlv.GetDataWithoutTopLevelTag()); + + TDesC8* terminalRspPtr = &terminalRsp; + TMockLtsyData1 termRespData(terminalRspPtr); + termRespData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, data, aErrorForExpect); + + CleanupStack::PopAndDestroy(&terminalRsp); + CleanupStack::PopAndDestroy(&data); + } + +/** + * prepare data and call iSat.TerminalRsp(reqStatus, aRSatTypeOfCommand, aRspPckg); + * @param aRspPckg - data for response + * @param aExpectedError - error, which is expected from CTSY + */ +void CCSatSetUpEventListFU::TerminalResponseL(const TDesC8& aRspPckg, TInt aExpectedError) + { + TRequestStatus reqStatus; + iSat.TerminalRsp(reqStatus, RSat::ESetUpEventList, aRspPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(aExpectedError, reqStatus.Int()); + } + +/** + * prepare data and call iSat.EventDownload; + * @param aEvent - code of event + */ +void CCSatSetUpEventListFU::PrepareAndCallEventDownloadL(const TUint8 aEvent) + { + PrepareAndCallEventDownloadL( aEvent, + NULL, // aClientSat, + EFalse, // aIsUnsolicited, + KErrNone); //aErrorForExpect) + } + +/** + * prepare data and call iSat.EventDownload; + * @param aEvent - code of event + * @param aUseOwnSat - if interal sat (iSat) is used + * @param aClientSat - pointer to sat object (if aUseOwnSat == EFalse) + * @param aIsUnsolicited - if this command is unsolicited one + * @param aErrorForExpect - error, expected from LTSY + */ +void CCSatSetUpEventListFU::PrepareAndCallEventDownloadL( const TUint8 aEvent, + const RSat* aClientSat, + TBool aIsUnsolicited, + TInt aErrorForExpect) + { + RBuf8 data; + CleanupClosePushL(data); + + RBuf8 eventData; + CleanupClosePushL(eventData); + + RSat::TEventDownloadBaseV2 baseEventInfo; + RSat::TEventDownloadBaseV2Pckg baseEventInfoPckg(baseEventInfo); + + // BY DEFAULT use base event info + eventData.CreateL(baseEventInfoPckg); + + TRequestStatus requestStatus; + // Create envelope + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(aEvent); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte( (aEvent ==KEventIdleScreenAvailable)? KDisplay : KMe); + envelope.AddByte(KSim); + + RSat::TEventList singleEvent( RSat::KUserActivity); + switch (aEvent) + { + case KEventUserActivity: + { + singleEvent = RSat::KUserActivity; + break; + } + + case KEventIdleScreenAvailable: + { + singleEvent = RSat::KIdleScreenAvailable; + break; + } + + case KEventBrowserTermination: + { + singleEvent = RSat::KBrowserTermination; + + // change default event data + RSat::TBrowserTerminationEventV2 browserTermination; + RSat::TBrowserTerminationEventV2Pckg browserTerminationPckg(browserTermination); + browserTermination.iCause = RSat::EUserTermination; + // use special (browserTermination) event info + eventData.Close(); + eventData.CreateL(browserTerminationPckg); + + // Cause + envelope.AddTag( KTlvBrowserTerminationCauseTag ); + envelope.AddByte( KBrowserTerminationUser ); + break; + } + + case KEventLanguageSelection: + { + singleEvent = RSat::KLanguageSelection; + + // change default event data + RSat::TLanguageSelectionEventV2 lang; + RSat::TLanguageSelectionEventV2Pckg langPck(lang); + //data for event download + TUint languageCode(0xABCD); // some language code + lang.iLanguage = languageCode; + // use special (lang) event info + eventData.Close(); + eventData.CreateL(langPck); + + // Language + envelope.AddTag( KTlvLanguageTag ); + envelope.AddByte( TUint8( ( languageCode >> 8 ) & 0x7f ) );// MSB + envelope.AddByte( TUint8( ( languageCode ) & 0x7f ) );// LSB + break; + } + + case KEventDataAvailable: + { + singleEvent = RSat::KDataAvailable; + + // change default event data + RSat::TDataAvailableEventV2 dataAvailable; + RSat::TDataAvailableEventV2Pckg dataAvailablePckg(dataAvailable); + TUint8 length = 0x22; // some length + //data for event download + dataAvailable.iStatus.Append(KChannelStatusByte1); + dataAvailable.iLength = length; + // use special (dataavailable) event info + eventData.Close(); + eventData.CreateL(dataAvailablePckg); + + // Channel status + envelope.AddTag( KTlvChannelStatusTag ); + envelope.AddByte( KChannelStatusByte1 ); + // Channel data length + envelope.AddTag( KTlvChannelDataLengthTag ); + envelope.AddByte( length ); + break; + } + + case KEventChannelStatus: + { + singleEvent = RSat::KChannelStatus; + + // change default event data + RSat::TChannelStatusEventV2 channelStatus; + RSat::TChannelStatusEventV2Pckg channelStatusPckg(channelStatus); + //data for event download + channelStatus.iStatus.Append(KChannelStatusByte1); + // use special (channel status) event info + eventData.Close(); + eventData.CreateL(channelStatusPckg); + + // Channel status + envelope.AddTag( KTlvChannelStatusTag ); + envelope.AddByte( KChannelStatusByte1 ); + break; + } + + case KLocalConnection_missing: + { + singleEvent = RSat::KCardReaderStatus; + break; + } + + case KDisplayParamsChanges_missing: + { + singleEvent = RSat::KCardReaderStatus; + break; + } + + case KEventCardReaderStatus: + { + singleEvent = RSat::KCardReaderStatus; + break; + } + + // Not reported to the client + case KEventMTCall: + case KEventCallConnected: + case KEventCallDisconnected: + case KEventLocationStatus: + case KEventAccessTechnologyChange: + default: + { + // we have nothing to do here + // so let's go out + CleanupStack::PopAndDestroy(&eventData); + CleanupStack::PopAndDestroy(&data); + return; + } + + }// end Switch + + // if this request is NOT Unsolicited + if (!aIsUnsolicited) + { + TDesC8* envelopePtr = &const_cast(envelope.End()); + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId, + data, aErrorForExpect); + } + + // this if-else just because of multiple client test + if (aClientSat) + { + // it means that this request is from the second client + aClientSat->EventDownload(requestStatus, singleEvent, eventData); + } + else + { + //ETel calls event download + iSat.EventDownload(requestStatus, singleEvent, eventData); + } + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(aErrorForExpect, requestStatus.Int()) + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&eventData); + CleanupStack::PopAndDestroy(&data); + } + +/** + * prepare data and force TSY to send ENVELOPE + * @param aEvent - code of event + * @param aIsEnvelopeSent- ETrue if ENVELOPE is really sent to LTSY + */ +void CCSatSetUpEventListFU::EnvelopeFromTsyL(const TUint8 aEvent, TBool aIsEnvelopeSent) + { + static const TUint8 someId = 111; + + switch (aEvent) + { + case KEventMTCall: + { + // ---Prepare and call CompleteMTCallL with correct data----------------------------- + //Type of Number (TON) and numbering plan identification (NPI). + //MSB - 1, Type of Number - 011 (Network Specific Number), Numbering Plan - 1001 (Private numbering plan) 10111001 = B9 Hex + const TUint8 KTonAndNpi = (0x80) | (RMobilePhone::ENetworkSpecificNumber << 4) | (RMobilePhone::EPrivateNumberPlan); + TBuf8 address; + address.Append(KTonAndNpi); + address.Append(_L8("1234567")); //dummy address + TBuf8 subAddress; + subAddress.Append(_L8("12345678910")); //dummy subAddress + CompleteMTCallL(someId, &address, &subAddress, aIsEnvelopeSent); + + // ---Prepare and call CompleteMTCallL with NULL-address and subAddress lenght ------ + address.Zero(); + subAddress.Zero(); + address.Append(KTonAndNpi); + CompleteMTCallL(someId, &address, &subAddress, aIsEnvelopeSent); + + // ---Prepare and call CompleteMTCallL without KTonAndNpi ---------------------------- + address.Zero(); + CompleteMTCallL(someId, &address, &subAddress, aIsEnvelopeSent); + break; + } + + case KEventCallConnected: + { + // ---Prepare and call CompleteCallConnectedL with nearEnd = EFalse -------------------- + TBool nearEnd = EFalse; + CompleteCallConnectedL(someId, nearEnd, aIsEnvelopeSent); + + // ---Prepare and call CompleteCallConnectedL with nearEnd = ETrue -------------------- + nearEnd = ETrue; + CompleteCallConnectedL(someId, nearEnd, aIsEnvelopeSent); + break; + } + + case KEventCallDisconnected: + { + // ---Prepare and call CompleteCallDisconnectedL with nearEnd = EFalse and cause given--- + TBool nearEnd = EFalse; + TBuf8 cause; + cause.Append(_L8("1234567")); + CompleteCallDisconnectedL(someId, nearEnd, &cause, aIsEnvelopeSent); + + // ---Prepare and call CompleteCallDisconnectedL with nearEnd = ETrue and without cause-- + nearEnd = ETrue; + cause.Zero(); + CompleteCallDisconnectedL(someId, nearEnd, &cause, aIsEnvelopeSent); + break; + } + + case KEventLocationStatus: + { + // ---Prepare and call CompleteLocationStatusL with KLocationStatusNormalService-------- + TUint8 locationStatus = KLocationStatusNormalService; + TBuf8 countryCode(_L8("926")); // code of some Moscow ME operator + TUint16 locationAreaCode = KLocationAreaCode; + TUint16 cellId = KCellId; + CompleteLocationStatusL(locationStatus, countryCode, locationAreaCode, cellId, aIsEnvelopeSent); + + // ---Prepare and call CompleteLocationStatusL with KLocationStatusLimitedService-------- + locationStatus = KLocationStatusLimitedService; + CompleteLocationStatusL(locationStatus, countryCode, locationAreaCode, cellId, aIsEnvelopeSent); + + // ---Prepare and call CompleteLocationStatusL with another countryCode------------------ + countryCode.Copy(_L8("124")); + CompleteLocationStatusL(locationStatus, countryCode, locationAreaCode, cellId, aIsEnvelopeSent); + + // ---Prepare and call CompleteLocationStatusL with another locationAreaCode------------- + locationAreaCode = 333; // some dummy code + CompleteLocationStatusL(locationStatus, countryCode, locationAreaCode, cellId, aIsEnvelopeSent); + + // ---Prepare and call CompleteLocationStatusL with another cellId----------------------- + cellId = 444; // some dummy id + CompleteLocationStatusL(locationStatus, countryCode, locationAreaCode, cellId, aIsEnvelopeSent); + + // ---Prepare and call CompleteLocationStatusL with the same data------------------------ + CompleteLocationStatusL(locationStatus, countryCode, locationAreaCode, cellId, EFalse); + break; + } + + case KEventAccessTechnologyChange: + { + TUint8 aAccTechChange(0); + CompleteAccessTechnologyChangeL(aAccTechChange, aIsEnvelopeSent); + break; + } + + default: + { + break; + } + + }// end of swith + } + + +/** + * Invokes CSatEventDownloadTsy::CompleteMTCallL() + * @param aTransactionId - id of transaction + * @param aAddress - address for complete + * @param aSubAddress - subaddress for complete + * @param aIsEnvelopeSent- ETrue if ENVELOPE is really sent to LTSY + */ +void CCSatSetUpEventListFU::CompleteMTCallL(TUint8 aTransactionId, + TDesC8* aAddress, + TDesC8* aSubAddress, + TBool aIsEnvelopeSent) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + // call TSY's CompleteMTCallL + TMockLtsyData3 mtCallPack(aTransactionId, aAddress, aSubAddress); + mtCallPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatMtCallIndId, KErrNone, data, KDelay); // use KDelay to have time for preparing MockL data + data.Close(); + + if (aIsEnvelopeSent) + { + //Prepare data MockL data for TSY's ENVELOPE + // Create envelope + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag ( KTlvEventListTag ); + envelope.AddByte( KEventMTCall ); + // Device identities + envelope.AddTag ( KTlvDeviceIdentityTag ); + envelope.AddByte( KNetwork ); + envelope.AddByte( KSim ); + // Transaction identifier + envelope.AddTag ( KTlvTransactionIdentifierTag ); + envelope.AddByte(aTransactionId); + + if (aAddress->Length()) + { + envelope.AddTag ( KTlvAddressTag ); + envelope.AddData( *aAddress ); + } + + if (aSubAddress->Length()) + { + envelope.AddTag( KTlvSubaddressTag ); + envelope.AddData( *aSubAddress ); + } + + TDesC8* envelopePtr = &const_cast(envelope.End()); + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,data); + } + + // wait for CompleteMTCallL + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(&data); + AssertMockLtsyStatusL(); + } + +/** + * Invokes CSatEventDownloadTsy::CompleteCallConnectedL() + * @param aTransactionId - id of transaction + * @param aNearEnd - indicates phone (KMe) or network (KNetwork) + * @param aIsEnvelopeSent- ETrue if ENVELOPE is really sent to LTSY + */ +void CCSatSetUpEventListFU::CompleteCallConnectedL(TUint8 aTransactionId, TBool aNearEnd, + TBool aIsEnvelopeSent) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + TMockLtsyData2 callConnectedTechPack(aTransactionId, aNearEnd); + callConnectedTechPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallConnectedIndId, KErrNone, data, KDelay); // use KDelay to have time for preparing MockL data + data.Close(); + + if (aIsEnvelopeSent) + { + // Create envelope + TTlv envelope; + envelope.Begin( KBerTlvEventDownloadTag ); + + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventCallConnected); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(aNearEnd ? KMe : KNetwork); + envelope.AddByte(KSim); + // Transaction identifier + envelope.AddTag(KTlvTransactionIdentifierTag); + envelope.AddByte(aTransactionId); + + TDesC8* envelopePtr = &const_cast(envelope.End()); + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,data); + } + + // wait for CompleteMTCallL + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(&data); + AssertMockLtsyStatusL(); + } + +/** + * Invokes CSatEventDownloadTsy::CompleteCallDisconnectedL() + * @param aTransactionId - id of transaction + * @param aNearEnd - indicates phone (KMe) or network (KNetwork) + * @param aCause - the initiator of disconnect + * @param aIsEnvelopeSent- ETrue if ENVELOPE is really sent to LTSY + */ +void CCSatSetUpEventListFU::CompleteCallDisconnectedL(TUint8 aTransactionId, TBool aNearEnd, + TDesC8* aCause, TBool aIsEnvelopeSent) + { + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + TMockLtsyData3 callDisconnectedLtsyData(aTransactionId, aNearEnd, aCause); + callDisconnectedLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallDisconnectedIndId, KErrNone, data, KDelay); // use KDelay to have time for preparing MockL data + data.Close(); + + if (aIsEnvelopeSent) + { + // Create envelope data + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventCallDisconnected); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(aNearEnd ? KMe : KNetwork); + envelope.AddByte(KSim); + // Transaction identifier + envelope.AddTag(KTlvTransactionIdentifierTag); + envelope.AddByte(aTransactionId); + // Cause + if (aCause->Length() != 0) + { + envelope.AddTag (KTlvCauseTag); + envelope.AddData(*aCause); + } + + TDesC8* envelopePtr = &const_cast(envelope.End()); + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,data); + } + // wait for CompleteMTCallL + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(&data); + AssertMockLtsyStatusL(); + } + + + +/** + * Invokes CSatEventDownloadTsy::CompleteLocationStatusL() + * @param aLocationStatus - status + * @param aCountryCode - operator's code + * @param aLocationAreaCode - location area code + * @param aCellId - cell id + * @param aIsEnvelopeSent- ETrue if ENVELOPE is really sent to LTSY + */ +void CCSatSetUpEventListFU::CompleteLocationStatusL(TUint8 aLocationStatus, + TDes8& aCountryCode, + TUint16 aLocationAreaCode, + TUint16 aCellId, + TBool aIsEnvelopeSent) + { + RBuf8 data; + CleanupClosePushL(data); + TRequestStatus requestStatus; + TDesC8* countryCodePtr = &aCountryCode; + TMockLtsyData4locationStatusData( aLocationStatus, + countryCodePtr, + aLocationAreaCode, + aCellId); + locationStatusData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatLocationStatusIndId, KErrNone, data, KDelay); // use KDelay to have time for preparing MockL data + data.Close(); + + if (aIsEnvelopeSent) + { + // Create envelope data + TTlv envelope; + envelope.Begin ( KBerTlvEventDownloadTag ); + // Event list + envelope.AddTag ( KTlvEventListTag ); + envelope.AddByte( KEventLocationStatus ); + // Device identities + envelope.AddTag ( KTlvDeviceIdentityTag ); + envelope.AddByte( KMe ); + envelope.AddByte( KSim ); + // Locationstatus + envelope.AddTag ( KTlvLocationStatusTag ); + envelope.AddByte( TUint8(aLocationStatus) ); + + // Location information, this is included only if status indicates + // normal service + if ( KLocationStatusNormalService == aLocationStatus ) + { + envelope.AddTag ( KTlvLocationInformationTag ); + envelope.AddData( aCountryCode ); + // Mobile country & network codes + envelope.AddByte( TUint8( aLocationAreaCode >> 8 ) ); + envelope.AddByte( TUint8( aLocationAreaCode ) ); + envelope.AddByte( TUint8( aCellId >> 8 ) ); + envelope.AddByte( TUint8( aCellId ) ); + } + + TDesC8* envelopePtr = &const_cast(envelope.End()); + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,data); + } + + // wait for CompleteMTCallL + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(&data); + AssertMockLtsyStatusL(); + } +/** + * Invokes CSatEventDownloadTsy::CompleteAccessTechnologyChangeL() + * @param aAccTechChange - Access technology + * @param aIsEnvelopeSent- ETrue if ENVELOPE is really sent to LTSY + */ +void CCSatSetUpEventListFU::CompleteAccessTechnologyChangeL(TUint8 aAccTechChange, TBool aIsEnvelopeSent) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + TMockLtsyData1 accTechData( aAccTechChange); + accTechData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatAccessTechnologyChangeIndId, KErrNone, data, KDelay); // use KDelay to have time for preparing MockL data + data.Close(); + + if (aIsEnvelopeSent) + { + TTlv envelope; + envelope.Begin ( KBerTlvEventDownloadTag ); + // event list + envelope.AddTag ( KTlvEventListTag ); + envelope.AddByte( KEventAccessTechnologyChange ); + // device identities + envelope.AddTag ( KTlvDeviceIdentityTag ); + envelope.AddByte( KMe ); + envelope.AddByte( KSim ); + envelope.AddTag( KTlvAccessTechnologyTag ); + envelope.AddByte( aAccTechChange ); + + TDesC8* envelopePtr = &const_cast(envelope.End()); + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,data); + } + // wait for CompleteMTCallL + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(&data); + AssertMockLtsyStatusL(); + } + + +/** + * Tests all possible "TERMINAL RESPONSE" cases. + * RSat::TerminalRsp should complets with KErrNone for all valid responses and KErrCorrupt + * for those that can not be used with "SET UP EVENT LIST" command + */ +void CCSatSetUpEventListFU::DoTestTerminalResponseL() + { + static const struct + { + RSat::TPCmdResult iGeneralResult; + RSat::TAdditionalInfoType iInfoType; + TBool iIntentionallyOmmitAdditionalInfo; // skip AdditionalInfo + TUint8 iAdditionalInfo; + TInt iExpectedResult; + } + KResponsesToTest[] = + { + { + // 0x01 - Command performed with partial comprehension; + RSat::KPartialComprehension, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x02 - Command performed, with missing information; + RSat::KMissingInformation, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x03 - REFRESH performed with additional EFs read; + RSat::KRefreshAdditionEFRead, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x04 - Command performed successfully, but requested icon could not be displayed; + RSat::KSuccessRequestedIconNotDisplayed, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x05 - Command performed, but modified by call control by NAA; + RSat::KModifiedByCallControl, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x06 - Command performed successfully, limited service; + RSat::KSuccessLimitedService, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x07 - Command performed with modification; + RSat::KPerformedWithModifications, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x08 - REFRESH performed but indicated NAA was not active; + RSat::KRefreshUSIMNotActive, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x09 - Command performed successfully, tone not played; + RSat::KPlayTonePerformedSuccessfully, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x10 - Proactive UICC session terminated by the user; + RSat::KPSessionTerminatedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x11 - Backward move in the proactive UICC session requested by the user; + RSat::KBackwardModeRequestedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x12 - No response from user; + RSat::KNoResponseFromUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x13 - Help information required by the user; + RSat::KHelpRequestedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x14 - reserved for GSM/3G. + RSat::KUssdTransactionTerminatedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x20 - terminal currently unable to process command; + RSat::KMeUnableToProcessCmd, + RSat::KMeProblem, + EFalse, + 0xAE, // dummy additional info + KErrNone + }, + { + // 0x20 without additional information (erroneous) + RSat::KMeUnableToProcessCmd, + RSat::KMeProblem, + ETrue, // Intentional error ! + 0, + KErrCorrupt + }, + + { + // 0x21 - Network currently unable to process command; + RSat::KNetworkUnableToProcessCmd, + RSat::KSatNetworkErrorInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x22 - User did not accept the proactive command; + RSat::KPCmdNotAcceptedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x23 - User cleared down call before connection or network release; + RSat::KCallClearedBeforeConnectionOrReleased, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x24 - Action in contradiction with the current timer state; + RSat::KContradictionWithTimerState, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x25 - Interaction with call control by NAA, temporary problem; + RSat::KInteractionWithCCTemporaryError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x26 - Launch browser generic error code; + RSat::KLaunchBrowserError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x27 - MMS temporary problem. + RSat::KMMSTemporaryProblem, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x30 - Command beyond terminal's capabilities; + RSat::KCmdBeyondMeCapabilities, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x31 - Command type not understood by terminal; + RSat::KCmdTypeNotUnderstood, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x32 - Command data not understood by terminal; + RSat::KCmdDataNotUnderstood, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x33 - Command number not known by terminal; + RSat::KCmdNumberNotKnown, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x34 - reserved for GSM/3G; + RSat::KSsReturnError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x35 - reserved for GSM/3G; + RSat::KSmsRpError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x36 - Error, required values are missing; + RSat::KErrorRequiredValuesMissing, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x37 - reserved for GSM/3G; + RSat::KUssdReturnError, + RSat::KSatNetworkErrorInfo, + EFalse, + 0, + KErrCorrupt + }, + { + // 0x38 - MultipleCard commands error; + RSat::KMultipleCardCmdsError, + RSat::KMeProblem, + EFalse, + 0, + KErrCorrupt + }, + { + // 0x39 - Interaction with call control by NAA, permanent problem; + RSat::KInteractionWithCCPermanentError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + + { + // 0x3A - Bearer Independent Protocol error; + RSat::KBearerIndepProtocolError, + RSat::KMeProblem, + EFalse, + RSat::KNoSpecificBIPError, + KErrCorrupt + }, + { + // 0x3A without additional information (erroneous) + RSat::KBearerIndepProtocolError, + RSat::KMeProblem, + ETrue, // Intentional error + 0, + KErrCorrupt + }, + { + // 0x3B - Access Technology unable to process command; + RSat::KAccessTechUnableProcessCmd, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x3C - Frames error; + RSat::KFramesError, + RSat::KMeProblem, + EFalse, + RSat::KNoSpecificCauseCanBeGiven, + KErrCorrupt + }, + { + // 0x3D - MMS Error. + RSat::KMMSError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + } + }; + + static const TUint8 events[] = {KEventUserActivity}; + + const TInt KNumberOfResponsesToTest = sizeof(KResponsesToTest)/ sizeof(KResponsesToTest[0]); + + TRequestStatus requestStatus; + // prepare TLV for + TTlv eventTlv; + PrepareTlv( eventTlv, events, sizeof(events)/sizeof(TUint8)); + const TDesC8& tlvEnd = eventTlv.End(); + + TBuf8<1> resultAddInfo; + RSat::TSetUpEventListV1 eventList; + RSat::TSetUpEventListV1Pckg eventListPck(eventList); + + + + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + // Post Notify itself + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(tlvEnd, KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + // ------------------------------------------------------------------------------------ + // Tell Mock to return KErrUnknown when dispatching forthcoming RSat::TerminalRsp() + // something like "Test A" of 001 test for TerminalResponse + //------------------------------------------------------------------------------------- + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, RSat::KSuccess, KNullDesC8, KErrUnknown); + + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.SetPCmdNumber(KPcmdNumber); + resp.iGeneralResult = RSat::KSuccess; + resp.iInfoType = RSat::KNoAdditionalInfo; + TerminalResponseL(respPckg, KErrUnknown); + AssertMockLtsyStatusL(); + + // --------------------------------------------------------------- + //Execute All cases for terminal response + // --------------------------------------------------------------- + + for(TInt i = 0; i < KNumberOfResponsesToTest; i++) + { + //Prepare data for ExpectL needed by NotifySetUpEventListPCmd + //and post that ExpectL + PrepareMockLDataWithExpL(KSetUpEventList); + // Post Notify itself + iSat.NotifySetUpEventListPCmd(requestStatus, eventListPck); + // post Complete with KErrNone + CompleteMockDispatchSatPcmdL(tlvEnd, KErrNone); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // now test a "TERMINAL RESPONSE" specific to this loop + resultAddInfo.Zero(); + if (( RSat::KNoAdditionalInfo == KResponsesToTest[i].iInfoType || + RSat::KMeProblem == KResponsesToTest[i].iInfoType ) && + !KResponsesToTest[i].iIntentionallyOmmitAdditionalInfo) + { + resultAddInfo.Append(KResponsesToTest[i].iAdditionalInfo); + } + + PrepareTerminalResponseMockDataWithExpL(KPcmdNumber, + KResponsesToTest[i].iGeneralResult, + resultAddInfo); + // call TerminalRsp + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPckg(resp); + resp.iGeneralResult = KResponsesToTest[i].iGeneralResult; + resp.iInfoType = KResponsesToTest[i].iInfoType; + if(!KResponsesToTest[i].iIntentionallyOmmitAdditionalInfo) + { + resp.iAdditionalInfo.Append(KResponsesToTest[i].iAdditionalInfo); + } + + resp.SetPCmdNumber(KPcmdNumber); + TerminalResponseL(respPckg, KResponsesToTest[i].iExpectedResult); + AssertMockLtsyStatusL(); + + // ---ENVELOPE: EVENT DOWNLOAD--- + // There is No ENVELOPE sent in case of errors! + } + + } + +