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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // The TEFUnit test suite for PacketContext in the Common TSY.

    15 // 

    16 //

    17 

    18 #include "cctsypacketcontextfu.h"

    19 #include "cctsypacketservicesfu.h"

    20 

    21 #include <etel.h>

    22 #include <etelmm.h>

    23 #include <et_clsvr.h>

    24 #include <ctsy/mmtsy_names.h>

    25 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    26 #include <test/tmockltsydata.h>

    27 #include <ctsy/ltsy/mltsydispatchpacketservicesinterface.h>

    28 

    29 CTestSuite* CCTsyPacketContextFU::CreateSuiteL(const TDesC& aName)

    30     {

    31     SUB_SUITE;

    32 

    33     ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestUnit00027L);

    34     ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestUnit00028L);

    35     ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestUnit00029L);

    36 

    37     END_SUITE;

    38     }

    39 

    40 

    41 //

    42 // Actual test cases

    43 //

    44 

    45 /**

    46 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UN00027

    47 @SYMComponent  telephony_ctsy

    48 @SYMTestCaseDesc Test support in CTSY for RPacketContext::Delete

    49 @SYMTestPriority High

    50 @SYMTestActions Invokes RPacketContext::Delete

    51 @SYMTestExpectedResults Pass

    52 @SYMTestType CT

    53 */

    54 void CCTsyPacketContextFU::TestUnit00027L()

    55     {

    56 

    57     OpenEtelServerL(EUseExtendedError);

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

    59     OpenPhoneL();

    60 

    61     RBuf8 data;

    62     CleanupClosePushL(data);

    63     

    64     RBuf8 expectData;

    65     CleanupClosePushL(expectData);

    66         

    67     RPacketService packetService;

    68     OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);    

    69    

    70     // Open new context

    71     TInfoName contextId;    

    72     RPacketContext packetContext;   

    73     packetContext.OpenNewContext(packetService, contextId); 

    74     CleanupClosePushL(packetContext);

    75  

    76     TInfoName primaryContext;

    77     TInfoName secondaryContext;

    78     primaryContext.Copy(KFirstAllocatedContextName);

    79     secondaryContext.Copy(KDefaultContextName);    

    80     

    81     //-------------------------------------------------------------------------

    82     // SEND Delete request when ContextStatus is Unknown

    83     //-------------------------------------------------------------------------

    84     TRequestStatus requestStatus;   

    85     packetContext.Delete(requestStatus);

    86     

    87     User::WaitForRequest(requestStatus);    

    88     ASSERT_EQUALS(KErrNotReady, requestStatus.Int());   

    89     AssertMockLtsyStatusL();

    90        

    91     // Set context in Active state

    92     SetContextActiveL(contextId);

    93   

    94     //----------------------------------

    95     // Send an unsupported request

    96     //----------------------------------

    97     

    98     RPacketContext::TDataVolume volume; 

    99     packetContext.GetDataVolumeTransferred(requestStatus, volume);

   100     User::WaitForRequest(requestStatus);        

   101     ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

   102     AssertMockLtsyStatusL();

   103     

   104 

   105     //-------------------------------------------------------------------------

   106     // TEST E: Unsolicited completion of RPacketContext::Delete

   107     // from LTSY.

   108     //-------------------------------------------------------------------------    

   109     TMockLtsyData1 <TInfoName > ltsyData(contextId);

   110     data.Close();

   111     ltsyData.SerialiseL(data);

   112     

   113     TRequestStatus mockLtsyStatus;

   114     

   115     iMockLTSY.NotifyTerminated(mockLtsyStatus);

   116     // send completion 

   117     iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, KErrNone, data);

   118 

   119     // wait for completion

   120     User::WaitForRequest(mockLtsyStatus);

   121     ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   122     AssertMockLtsyStatusL();

   123 

   124     //-------------------------------------------------------------------------

   125     // TEST A: failure to dispatch request to LTSY

   126     //-------------------------------------------------------------------------

   127     //TMockLtsyData1 <TInfoName> expData(contextId);

   128     TMockLtsyData1<TInfoName> expData(primaryContext);

   129     expectData.Close();

   130     expData.SerialiseL(expectData);

   131     

   132     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData, KErrNotSupported);

   133 

   134     packetContext.Delete(requestStatus);

   135     

   136     User::WaitForRequest(requestStatus);    

   137     ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());   

   138     AssertMockLtsyStatusL();

   139 

   140     //-------------------------------------------------------------------------

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

   142     //-------------------------------------------------------------------------

   143     iMockLTSY.ExpectL (MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);

   144     iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, KErrGeneral, data);

   145 

   146     packetContext.Delete(requestStatus);

   147     

   148     User::WaitForRequest(requestStatus);    

   149     ASSERT_EQUALS(KErrGeneral, requestStatus.Int());    

   150     AssertMockLtsyStatusL();

   151 

   152     //-------------------------------------------------------------------------

   153     // TEST C: Successful completion request of

   154     // RPacketContext::Delete when result is not cached.

   155     //-------------------------------------------------------------------------

   156     iMockLTSY.ExpectL (MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);

   157     iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, KErrNone, data);

   158 

   159     packetContext.Delete(requestStatus);

   160         

   161     User::WaitForRequest(requestStatus);    

   162     ASSERT_EQUALS(KErrNone, requestStatus.Int());   

   163     AssertMockLtsyStatusL();

   164 

   165     //-------------------------------------------------------------------------

   166     // TEST D: failure to modify context parameters when context deleted

   167     //-------------------------------------------------------------------------

   168     packetContext.ModifyActiveContext(requestStatus);

   169     User::WaitForRequest(requestStatus);        

   170     AssertMockLtsyStatusL();

   171     ASSERT_EQUALS(KErrNotReady, requestStatus.Int());

   172  

   173     iMockLTSY.ExpectL (MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);

   174     CleanupStack::PopAndDestroy(5, this); //packetContext, packetService, expectData, data, this 

   175     

   176     }

   177 

   178 /**

   179 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UN00028

   180 @SYMComponent  telephony_ctsy

   181 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::Delete

   182 @SYMTestPriority High

   183 @SYMTestActions Invokes multiple client requests to RPacketContext::Delete

   184 @SYMTestExpectedResults Pass

   185 @SYMTestType CT

   186 */

   187 void CCTsyPacketContextFU::TestUnit00028L()

   188     {                   

   189     OpenEtelServerL(EUseExtendedError);

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

   191     OpenPhoneL();

   192 

   193     RBuf8 data;

   194     CleanupClosePushL(data);    

   195     

   196     RBuf8 data2;

   197     CleanupClosePushL(data2);

   198     

   199     RBuf8 expectData;

   200     CleanupClosePushL(expectData);

   201     

   202     RBuf8 expectData2;

   203     CleanupClosePushL(expectData2);

   204 

   205     // Open second client

   206     RTelServer telServer2;

   207     TInt ret = telServer2.Connect();

   208     ASSERT_EQUALS(KErrNone, ret);

   209     CleanupClosePushL(telServer2);

   210 

   211     RMobilePhone phone2;

   212     ret = phone2.Open(iTelServer,KMmTsyPhoneName);

   213     ASSERT_EQUALS(KErrNone, ret);

   214     CleanupClosePushL(phone2);

   215     

   216     RPacketService packetService;

   217     OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   218     

   219     RPacketService packetService2;                

   220     ret = packetService2.Open(phone2);

   221     ASSERT_EQUALS(KErrNone, ret);

   222     CleanupClosePushL(packetService2);

   223     

   224     // Open first context

   225     TInfoName contextId;    

   226     RPacketContext packetContext;

   227     packetContext.OpenNewContext(packetService, contextId);

   228     CleanupClosePushL(packetContext);

   229     

   230     // Open second context

   231     TInfoName contextId2;   

   232     RPacketContext packetContext2;

   233     packetContext2.OpenNewContext(packetService2, contextId2);

   234     CleanupClosePushL(packetContext2);

   235     

   236     // Set first context in Active state

   237     SetContextActiveL(contextId);

   238     

   239     // Set second context in Active state

   240     SetContextActiveL(contextId2);

   241 

   242     //-------------------------------------------------------------------------

   243     // Test A: Test multiple clients requesting RPacketContext::Delete

   244     //-------------------------------------------------------------------------

   245     

   246     // data for first CompleteL

   247     TMockLtsyData1 <TInfoName > ltsyData(contextId);

   248     ltsyData.SerialiseL(data);

   249     

   250     // data for second CompleteL

   251     TMockLtsyData1 <TInfoName > ltsyData2(contextId2);

   252     ltsyData2.SerialiseL(data2);    

   253    

   254     // for the first request

   255     TRequestStatus requestStatus;

   256     TMockLtsyData1 <TInfoName> expData(contextId);

   257     expData.SerialiseL(expectData);

   258     

   259     // for the second request

   260     TRequestStatus requestStatus2;

   261     TMockLtsyData1 <TInfoName> expData2(contextId2);

   262     expData2.SerialiseL(expectData2);

   263             

   264     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);        

   265     iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, KErrNone, data);

   266     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData2);    

   267     iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, KErrNone, data2);

   268     

   269     // send first request

   270     packetContext.Delete(requestStatus);        

   271     

   272     // send second request

   273     packetContext2.Delete(requestStatus2);

   274     

   275     // wait for first answer

   276     User::WaitForRequest(requestStatus);        

   277     ASSERT_EQUALS(KErrNone, requestStatus.Int());

   278         

   279     // wait for second answer

   280     User::WaitForRequest(requestStatus2);       

   281     ASSERT_EQUALS(KErrNone, requestStatus2.Int());

   282 

   283     AssertMockLtsyStatusL();

   284     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData2);

   285     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);

   286     CleanupStack::PopAndDestroy(2); // expectData2, expectData

   287     CleanupStack::PopAndDestroy(9, this); //packetContext2, packetContext, packetService2, packetService, phone2, telServer2, data,data2 this  

   288     }

   289 

   290 /**

   291 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UN00029

   292 @SYMComponent  telephony_ctsy

   293 @SYMTestCaseDesc Test support in CTSY for RPacketContext::Delete with timeout

   294 @SYMTestPriority High

   295 @SYMTestActions Invokes RPacketContext::Delete and tests for timeout

   296 @SYMTestExpectedResults Pass

   297 @SYMTestType CT

   298 */

   299 void CCTsyPacketContextFU::TestUnit00029L()

   300     {

   301 

   302     OpenEtelServerL(EUseExtendedError);

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

   304     OpenPhoneL();

   305 

   306     RBuf8 data;

   307     CleanupClosePushL(data);

   308     

   309     RBuf8 expectData;

   310     CleanupClosePushL(expectData);

   311     

   312     RPacketService packetService;

   313     OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   314     

   315     // Open new context

   316     TInfoName contextId;    

   317     RPacketContext packetContext;   

   318     packetContext.OpenNewContext(packetService, contextId); 

   319     CleanupClosePushL(packetContext);

   320     

   321     // Set context in Active state

   322     SetContextActiveL(contextId);

   323     

   324     //-------------------------------------------------------------------------

   325     // Test A: Test timeout of RPacketContext::Delete

   326     //-------------------------------------------------------------------------     

   327     TRequestStatus requestStatus;   

   328     TMockLtsyData1 <TInfoName> expData(contextId);

   329     expData.SerialiseL(expectData);    

   330     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);

   331     

   332     packetContext.Delete(requestStatus);

   333         

   334     User::WaitForRequest(requestStatus);    

   335     ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());   

   336     AssertMockLtsyStatusL();

   337     

   338     iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, expectData);

   339     CleanupStack::PopAndDestroy(5, this); //packetContext, packetService, data, expectData, this

   340     }