telephonyserverplugins/common_tsy/test/component/src/cctsynetworkcontrolfu.cpp
branchRCL_3
changeset 82 042fd2753b8f
parent 66 07a122eea281
equal deleted inserted replaced
74:9200f38b1324 82:042fd2753b8f
   100 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetLastUsedAccessTechnology0001L);
   100 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetLastUsedAccessTechnology0001L);
   101 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001L);
   101 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001L);
   102     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001aL);
   102     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001aL);
   103     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001bL);
   103     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001bL);
   104     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0002L);
   104     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0002L);
   105     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0004L);    
       
   106     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001L);
   105     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001L);
   107     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001aL);
   106     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001aL);
   108     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001bL);
   107     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001bL);
   109     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001cL);
   108     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001cL);
   110     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0002L);
   109     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0002L);
   111     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0004L);    
       
   112 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0001L);
   110 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0001L);
   113 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0002L);
   111 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0002L);
   114 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0004L);
   112 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0004L);
   115 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0005L);
   113 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0005L);
   116 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyPreferredNetworksListChange0001L);
   114 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyPreferredNetworksListChange0001L);
   117     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyPreferredNetworksListChange0002L);
   115     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyPreferredNetworksListChange0002L);           
   118     ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyPreferredNetworksListChange0004L);    
       
   119 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0001L);
   116 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0001L);
   120 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0002L);
   117 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0002L);
   121 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0004L);
   118 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0004L);
   122 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0001L);
   119 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0001L);
   123 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0002L);
   120 	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0002L);
  5271 
  5268 
  5272     prefNetworks[2].iAccess = RMobilePhone::KNetworkAccessGsm;
  5269     prefNetworks[2].iAccess = RMobilePhone::KNetworkAccessGsm;
  5273     prefNetworks[2].iCountryCode = _L("262");
  5270     prefNetworks[2].iCountryCode = _L("262");
  5274     prefNetworks[2].iNetworkId = _L("03");
  5271     prefNetworks[2].iNetworkId = _L("03");
  5275         
  5272         
  5276     for( TInt i=0; i < 3; ++i )
  5273     for( TInt i=0; i < 3; i++ )
  5277         {
  5274         {
  5278         list->AddEntryL(prefNetworks[i]);
  5275         list->AddEntryL(prefNetworks[i]);
  5279         }
  5276         }
  5280     
  5277     
  5281     TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list);    
  5278     TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list);    
  5341 
  5338 
  5342 /**
  5339 /**
  5343 @SYMTestCaseID          BA-CTSY-NTWC-MSPNL-0001b
  5340 @SYMTestCaseID          BA-CTSY-NTWC-MSPNL-0001b
  5344 @SYMPREQ                417-71654
  5341 @SYMPREQ                417-71654
  5345 @SYMComponent           telephony_ctsy
  5342 @SYMComponent           telephony_ctsy
  5346 @SYMTestCaseDesc        Test support in CTSY for RMobilePhone::StorePreferredNetworksListL 
  5343 @SYMTestCaseDesc        Test support in CTSY for RMobilePhone::StorePreferredNetworksListL with error
  5347                         with error and with duplicate LTSY complete message
       
  5348 @SYMTestPriority        High
  5344 @SYMTestPriority        High
  5349 @SYMTestActions         1. Invoke RMobilePhone::StorePreferredNetworksListL.
  5345 @SYMTestActions         1. Invoke RMobilePhone::StorePreferredNetworksListL.
  5350                         2. LTSY returns error.
  5346                         2. LTSY returns error.  
  5351                         3. Test code receives error.
  5347 @SYMTestExpectedResults Test code receives error. 
  5352                         3. Invoke RMobilePhone:StorePreferredNetworksListL.
       
  5353                         4. LTSY returns duplicate complete message with KErrNone
       
  5354                         5. Duplicate complete message is ignored and test code receives KErrNone.  
       
  5355 @SYMTestExpectedResults All tests pass. 
       
  5356 @SYMTestType            CT
  5348 @SYMTestType            CT
  5357 */
  5349 */
  5358 void CCTsyNetworkControlFU::TestStorePreferredNetworksListL0001bL()
  5350 void CCTsyNetworkControlFU::TestStorePreferredNetworksListL0001bL()
  5359     {
  5351     {
  5360 
  5352 
  5392 
  5384 
  5393     User::WaitForRequest(requestStatus);
  5385     User::WaitForRequest(requestStatus);
  5394     AssertMockLtsyStatusL();
  5386     AssertMockLtsyStatusL();
  5395     ASSERT_EQUALS(KErrUnknown, requestStatus.Int());
  5387     ASSERT_EQUALS(KErrUnknown, requestStatus.Int());
  5396 
  5388 
  5397     // Invoke Store request - LTSY returns duplicate complete messages with KErrNone
  5389     // Invoke Store request - LTSY returns KErrNotSupported
  5398     
  5390     
  5399     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
  5391     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
  5400     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);
  5392     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNotSupported);
  5401     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);    
  5393     
  5402 
       
  5403     iPhone.StorePreferredNetworksListL(requestStatus, list);
  5394     iPhone.StorePreferredNetworksListL(requestStatus, list);
  5404 
  5395 
  5405     User::WaitForRequest(requestStatus);
  5396     User::WaitForRequest(requestStatus);
  5406     AssertMockLtsyStatusL();
  5397     AssertMockLtsyStatusL();
  5407     ASSERT_EQUALS(KErrNone, requestStatus.Int());
       
  5408     
       
  5409     // Invoke Store request - LTSY returns KErrNotSupported
       
  5410     
       
  5411     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data, KErrNotSupported);
       
  5412     
       
  5413     iPhone.StorePreferredNetworksListL(requestStatus, list);
       
  5414 
       
  5415     User::WaitForRequest(requestStatus);
       
  5416     AssertMockLtsyStatusL();
       
  5417     ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
  5398     ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
  5418    
  5399     
  5419     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5400     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5420     }
  5401     }
  5421 
  5402 
  5422 /**
  5403 /**
  5423 @SYMTestCaseID          BA-CTSY-NTWC-MSPNL-0002
  5404 @SYMTestCaseID          BA-CTSY-NTWC-MSPNL-0002
  5461     
  5442     
  5462     // Invoke Store request
  5443     // Invoke Store request
  5463     
  5444     
  5464     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
  5445     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
  5465     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);
  5446     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);
  5466     
  5447         
  5467     iPhone.StorePreferredNetworksListL(requestStatus, list);
  5448     iPhone.StorePreferredNetworksListL(requestStatus, list);
  5468 
  5449 
  5469     // Cancel outstanding request
  5450     // Cancel outstanding request
  5470     iPhone.CancelAsyncRequest(EMobilePhoneStorePreferredNetworksList);    
  5451     iPhone.CancelAsyncRequest(EMobilePhoneStorePreferredNetworksList);    
  5471     
  5452     
  5472     User::WaitForRequest(requestStatus);
  5453     User::WaitForRequest(requestStatus);
  5473     AssertMockLtsyStatusL();
  5454     AssertMockLtsyStatusL();
  5474     ASSERT_EQUALS(KErrNone, requestStatus.Int());
  5455     ASSERT_EQUALS(KErrNone, requestStatus.Int());
  5475 
  5456 
  5476     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5457     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5477     
       
  5478     }
       
  5479 
       
  5480 /**
       
  5481 @SYMTestCaseID          BA-CTSY-NTWC-MSPNL-0004
       
  5482 @SYMPREQ                417-71654
       
  5483 @SYMComponent           telephony_ctsy
       
  5484 @SYMTestCaseDesc        Test support in CTSY for multiple client requests to RMobilePhone::StorePreferredNetworksListL
       
  5485 @SYMTestPriority        High
       
  5486 @SYMTestActions         1. Invoke RMobilePhone::StorePreferredNetworksListL.
       
  5487                         2. Invoke RMobilePhone::StorePreferredNetworksListL from second client.
       
  5488 @SYMTestExpectedResults Second cleint receives KErrServerBusy. 
       
  5489 @SYMTestType            CT
       
  5490 */
       
  5491 void CCTsyNetworkControlFU::TestStorePreferredNetworksListL0004L()
       
  5492     {
       
  5493 
       
  5494     OpenEtelServerL(EUseExtendedError);
       
  5495     CleanupStack::PushL(TCleanupItem(Cleanup,this));
       
  5496     OpenPhoneL();
       
  5497 
       
  5498     RBuf8 data;
       
  5499     CleanupClosePushL(data);
       
  5500 
       
  5501     TRequestStatus requestStatus;
       
  5502 
       
  5503     // Open second client
       
  5504     RTelServer telServer2;
       
  5505     TInt ret = telServer2.Connect();
       
  5506     ASSERT_EQUALS(KErrNone, ret);
       
  5507     CleanupClosePushL(telServer2);
       
  5508 
       
  5509     RMobilePhone phone2;
       
  5510     ret = phone2.Open(iTelServer,KMmTsyPhoneName);
       
  5511     ASSERT_EQUALS(KErrNone, ret);
       
  5512     CleanupClosePushL(phone2);
       
  5513     
       
  5514     TRequestStatus requestStatus2;
       
  5515     
       
  5516     // --- prepare data ---
       
  5517     
       
  5518     CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL();
       
  5519     CleanupStack::PushL(list);
       
  5520 
       
  5521     RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork;
       
  5522     
       
  5523     prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm;
       
  5524     prefNetwork.iCountryCode = _L("262");
       
  5525     prefNetwork.iNetworkId = _L("01");
       
  5526     
       
  5527     list->AddEntryL(prefNetwork);
       
  5528     
       
  5529     TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list);    
       
  5530     listData.SerialiseL(data);
       
  5531     
       
  5532     // Invoke Store request
       
  5533     
       
  5534     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
       
  5535         
       
  5536     iPhone.StorePreferredNetworksListL(requestStatus, list);
       
  5537     
       
  5538     // Invoke store request from second client
       
  5539     
       
  5540     phone2.StorePreferredNetworksListL(requestStatus2, list);
       
  5541     
       
  5542     // Wait for second request
       
  5543     User::WaitForRequest(requestStatus2);
       
  5544     AssertMockLtsyStatusL();
       
  5545     ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
       
  5546     
       
  5547     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);
       
  5548     
       
  5549     // Wait for first request
       
  5550     User::WaitForRequest(requestStatus);
       
  5551     AssertMockLtsyStatusL();
       
  5552     ASSERT_EQUALS(KErrNone, requestStatus.Int());
       
  5553     
       
  5554     CleanupStack::PopAndDestroy(5, this); // list, phone2, telServer2, data, this
       
  5555     
  5458     
  5556     }
  5459     }
  5557 
  5460 
  5558 /**
  5461 /**
  5559 @SYMTestCaseID          BA-CTSY-NTWC-CRMPPN-0001
  5462 @SYMTestCaseID          BA-CTSY-NTWC-CRMPPN-0001
  5635             retrieveMobilePhonePreferredNetworks); // retrievedList
  5538             retrieveMobilePhonePreferredNetworks); // retrievedList
  5636                                                    // activeRetriever
  5539                                                    // activeRetriever
  5637                                                    // retrieveMobilePhonePreferredNetworks
  5540                                                    // retrieveMobilePhonePreferredNetworks
  5638 
  5541 
  5639     CActiveScheduler::Install(NULL);
  5542     CActiveScheduler::Install(NULL);
  5640     
  5543 /*    
  5641     // Add new entry to the list
  5544     // Add new entry to the list
  5642     
  5545     
  5643     RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork2;
  5546     RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork2;
  5644     prefNetwork2.iAccess = RMobilePhone::KNetworkAccessGsm;
  5547     prefNetwork2.iAccess = RMobilePhone::KNetworkAccessGsm;
  5645     prefNetwork2.iCountryCode = _L("262");
  5548     prefNetwork2.iCountryCode = _L("262");
  5660 
  5563 
  5661     User::WaitForRequest(requestStatus);
  5564     User::WaitForRequest(requestStatus);
  5662    
  5565    
  5663     AssertMockLtsyStatusL();
  5566     AssertMockLtsyStatusL();
  5664     ASSERT_EQUALS(KErrNone, requestStatus.Int());
  5567     ASSERT_EQUALS(KErrNone, requestStatus.Int());
  5665     
  5568 */    
  5666     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5569     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5667 
  5570 
  5668     }
  5571     }
  5669 
  5572 
  5670 /**
  5573 /**
  5756             retrieveMobilePhonePreferredNetworks); // retrievedList
  5659             retrieveMobilePhonePreferredNetworks); // retrievedList
  5757                                                    // activeRetriever
  5660                                                    // activeRetriever
  5758                                                    // retrieveMobilePhonePreferredNetworks
  5661                                                    // retrieveMobilePhonePreferredNetworks
  5759 
  5662 
  5760     CActiveScheduler::Install(NULL);
  5663     CActiveScheduler::Install(NULL);
  5761     
  5664 /*    
  5762     // Remove the last entry from the list
  5665     // Remove the last entry from the list
  5763     
  5666     
  5764     list->DeleteEntryL(1);
  5667     list->DeleteEntryL(1);
  5765     
  5668     
  5766     TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData2(list);
  5669     TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData2(list);
  5775     iPhone.StorePreferredNetworksListL(requestStatus, list);
  5678     iPhone.StorePreferredNetworksListL(requestStatus, list);
  5776 
  5679 
  5777     User::WaitForRequest(requestStatus);
  5680     User::WaitForRequest(requestStatus);
  5778     AssertMockLtsyStatusL();
  5681     AssertMockLtsyStatusL();
  5779     ASSERT_EQUALS(KErrNone, requestStatus.Int());
  5682     ASSERT_EQUALS(KErrNone, requestStatus.Int());
  5780     
  5683  */   
  5781     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5684     CleanupStack::PopAndDestroy(3, this); // list, data, this
  5782 
  5685 
  5783     }
  5686     }
  5784 
  5687 
  5785 /**
  5688 /**
  5911     ASSERT_EQUALS(KErrUnknown, activeRetriever->iStatus.Int());
  5814     ASSERT_EQUALS(KErrUnknown, activeRetriever->iStatus.Int());
  5912     AssertMockLtsyStatusL();    
  5815     AssertMockLtsyStatusL();    
  5913 
  5816 
  5914     // Invoke Retrieve request - LTSY returns KErrNotSupported
  5817     // Invoke Retrieve request - LTSY returns KErrNotSupported
  5915     
  5818     
  5916     iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq, KErrNotSupported);
  5819     iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq);
       
  5820     iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrNotSupported, data);    
  5917     
  5821     
  5918     retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status());
  5822     retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status());
  5919     activeRetriever->Activate();
  5823     activeRetriever->Activate();
  5920     scheduler.StartScheduler();
  5824     scheduler.StartScheduler();
  5921 
  5825 
  6005      CleanupStack::PopAndDestroy(3, this); // list, data, this
  5909      CleanupStack::PopAndDestroy(3, this); // list, data, this
  6006     
  5910     
  6007     }
  5911     }
  6008 
  5912 
  6009 /**
  5913 /**
  6010 @SYMTestCaseID          BA-CTSY-NTWC-CRMPPN-0004
       
  6011 @SYMPREQ                417-71654
       
  6012 @SYMComponent           telephony_ctsy
       
  6013 @SYMTestCaseDesc        Test support in CTSY for multiple client requests to CRetrieveMobilePhonePreferredNetworks::Start
       
  6014 @SYMTestPriority        High
       
  6015 @SYMTestActions         1. Invoke CRetrieveMobilePhonePreferredNetworks::Start.
       
  6016                         2. Invoke CRetrieveMobilePhonePreferredNetworks::Start from second client.
       
  6017 @SYMTestExpectedResults Second client receives KErrInUse.
       
  6018 @SYMTestType            CT
       
  6019 */
       
  6020 void CCTsyNetworkControlFU::TestRetrieveMobilePhonePreferredNetworks0004L()
       
  6021     {
       
  6022      OpenEtelServerL(EUseExtendedError);
       
  6023      CleanupStack::PushL(TCleanupItem(Cleanup,this));
       
  6024      OpenPhoneL();
       
  6025 
       
  6026      RBuf8 data;
       
  6027      CleanupClosePushL(data);
       
  6028 
       
  6029      // Open second client
       
  6030      RTelServer telServer2;
       
  6031      TInt ret = telServer2.Connect();
       
  6032      ASSERT_EQUALS(KErrNone, ret);
       
  6033      CleanupClosePushL(telServer2);
       
  6034 
       
  6035      RMobilePhone phone2;
       
  6036      ret = phone2.Open(iTelServer,KMmTsyPhoneName);
       
  6037      ASSERT_EQUALS(KErrNone, ret);
       
  6038      CleanupClosePushL(phone2);
       
  6039      
       
  6040      // --- prepare data ---
       
  6041      
       
  6042      CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL();
       
  6043      CleanupStack::PushL(list);
       
  6044         
       
  6045      CFilteringActiveScheduler scheduler;
       
  6046      CActiveScheduler::Install(&scheduler);
       
  6047 
       
  6048      // Create first retriever
       
  6049      
       
  6050      CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks = 
       
  6051                          CRetrieveMobilePhonePreferredNetworks::NewL(iPhone);
       
  6052      CleanupStack::PushL(retrieveMobilePhonePreferredNetworks);
       
  6053      
       
  6054      CActiveRetriever::ResetRequestsNumber();
       
  6055      CActiveRetriever* activeRetriever = 
       
  6056                          CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks);
       
  6057      CleanupStack::PushL(activeRetriever);
       
  6058      scheduler.AddRetrieverL(*activeRetriever);
       
  6059 
       
  6060      // Create second retriever
       
  6061      
       
  6062      CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks2 = 
       
  6063                          CRetrieveMobilePhonePreferredNetworks::NewL(phone2);
       
  6064      CleanupStack::PushL(retrieveMobilePhonePreferredNetworks2);
       
  6065      
       
  6066      CActiveRetriever::ResetRequestsNumber();
       
  6067      CActiveRetriever* activeRetriever2 = 
       
  6068                          CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks2);
       
  6069      CleanupStack::PushL(activeRetriever2);
       
  6070      scheduler.AddRetrieverL(*activeRetriever2);
       
  6071      
       
  6072      TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData(list);    
       
  6073      completeLtsyData.SerialiseL(data);
       
  6074          
       
  6075      TRequestStatus mockLtsyStatus;
       
  6076      iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq);
       
  6077      iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrNone, data);    
       
  6078      
       
  6079      // Invoke Retrieve request
       
  6080        
       
  6081      retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status());
       
  6082      activeRetriever->Activate();
       
  6083 
       
  6084      // Invoke Retrieve request from second client
       
  6085      
       
  6086      retrieveMobilePhonePreferredNetworks->Start(activeRetriever2->Status());
       
  6087      activeRetriever2->Activate();
       
  6088      
       
  6089      scheduler.StartScheduler();
       
  6090      
       
  6091      ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());
       
  6092      ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int());
       
  6093      ASSERT_EQUALS(KErrInUse, activeRetriever2->iStatus.Int());
       
  6094      AssertMockLtsyStatusL();    
       
  6095         
       
  6096      CleanupStack::PopAndDestroy(4, 
       
  6097              retrieveMobilePhonePreferredNetworks); // activeRetriever2
       
  6098                                                     // retrieveMobilePhonePreferredNetworks2
       
  6099                                                     // activeRetriever
       
  6100                                                     // retrieveMobilePhonePreferredNetworks
       
  6101      
       
  6102      CActiveScheduler::Install(NULL);
       
  6103          
       
  6104      CleanupStack::PopAndDestroy(5, this); // list, phone2, telServer2, data, this
       
  6105     
       
  6106     }
       
  6107 
       
  6108 /**
       
  6109 @SYMTestCaseID BA-CTSY-NTWC-MGNRS-0001
  5914 @SYMTestCaseID BA-CTSY-NTWC-MGNRS-0001
  6110 @SYMPREQ 1551
  5915 @SYMPREQ 1551
  6111 @SYMCR 1595
  5916 @SYMCR 1595
  6112 @SYMComponent  telephony_ctsy
  5917 @SYMComponent  telephony_ctsy
  6113 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetNetworkRegistrationStatus
  5918 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetNetworkRegistrationStatus
  6535     iPhone.CancelAsyncRequest(EMobilePhoneNotifyStorePreferredNetworksListChange);
  6340     iPhone.CancelAsyncRequest(EMobilePhoneNotifyStorePreferredNetworksListChange);
  6536 
  6341 
  6537     TRequestStatus mockLtsyStatus;    
  6342     TRequestStatus mockLtsyStatus;    
  6538     iMockLTSY.NotifyTerminated(mockLtsyStatus);
  6343     iMockLTSY.NotifyTerminated(mockLtsyStatus);
  6539     
  6344     
  6540     User::WaitForRequest(requestStatus);
       
  6541     AssertMockLtsyStatusL();
       
  6542     ASSERT_EQUALS(KErrCancel, requestStatus.Int());
       
  6543     
       
  6544     // Invoke Store request
  6345     // Invoke Store request
  6545     
  6346     
  6546     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
  6347     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
  6547     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);    
  6348     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);    
  6548     
  6349     
  6555     
  6356     
  6556     User::WaitForRequest(storeRequestStatus);
  6357     User::WaitForRequest(storeRequestStatus);
  6557     AssertMockLtsyStatusL();
  6358     AssertMockLtsyStatusL();
  6558     ASSERT_EQUALS(KErrNone, storeRequestStatus.Int());    
  6359     ASSERT_EQUALS(KErrNone, storeRequestStatus.Int());    
  6559     
  6360     
  6560     // Start timer and check if any notification is received
  6361     User::WaitForRequest(requestStatus);
  6561 
  6362     AssertMockLtsyStatusL();
  6562     TRequestStatus waitStatus = KRequestPending;
       
  6563     RTimer timer;
       
  6564     timer.CreateLocal();
       
  6565     CleanupClosePushL(timer);
       
  6566     timer.After(waitStatus, TTimeIntervalMicroSeconds32(KOneSecond));  // Wait 1 sec
       
  6567     
       
  6568     User::WaitForRequest(requestStatus, waitStatus);     
       
  6569     AssertMockLtsyStatusL();
       
  6570     ASSERT_EQUALS(KErrNone, waitStatus.Int()); // timer fired
       
  6571     ASSERT_EQUALS(KErrCancel, requestStatus.Int());
  6363     ASSERT_EQUALS(KErrCancel, requestStatus.Int());
  6572     
  6364 
  6573     CleanupStack::PopAndDestroy(4, this); // timer, list, data, this
  6365     CleanupStack::PopAndDestroy(3, this); // list, data, this
  6574       
  6366       
  6575     }
       
  6576 
       
  6577 /**
       
  6578 @SYMTestCaseID          BA-CTSY-NTWC-MNPNLC-0004
       
  6579 @SYMPREQ                417-71654
       
  6580 @SYMComponent           telephony_ctsy
       
  6581 @SYMTestCaseDesc        Test support in CTSY for multiple client requests to RMobilePhone::NotifyPreferredNetworksListChange
       
  6582 @SYMTestPriority        High
       
  6583 @SYMTestActions         1. Invoke RMobilePhone::NotifyPreferredNetworksListChange.
       
  6584                         1. Invoke RMobilePhone::NotifyPreferredNetworksListChange from second client.
       
  6585                         2. Invoke RMobilePhone::StorePreferredNetworksListL.
       
  6586 @SYMTestExpectedResults Clients receive preferred network list notification
       
  6587 @SYMTestType            CT
       
  6588 */
       
  6589 void CCTsyNetworkControlFU::TestNotifyPreferredNetworksListChange0004L()
       
  6590     {
       
  6591 
       
  6592     OpenEtelServerL(EUseExtendedError);
       
  6593     CleanupStack::PushL(TCleanupItem(Cleanup,this));
       
  6594     OpenPhoneL();
       
  6595 
       
  6596     RBuf8 data;
       
  6597     CleanupClosePushL(data);
       
  6598     
       
  6599     // Open second client
       
  6600     RTelServer telServer2;
       
  6601     TInt ret = telServer2.Connect();
       
  6602     ASSERT_EQUALS(KErrNone, ret);
       
  6603     CleanupClosePushL(telServer2);
       
  6604 
       
  6605     RMobilePhone phone2;
       
  6606     ret = phone2.Open(iTelServer,KMmTsyPhoneName);
       
  6607     ASSERT_EQUALS(KErrNone, ret);
       
  6608     CleanupClosePushL(phone2);
       
  6609     
       
  6610     TRequestStatus requestStatus;
       
  6611     TRequestStatus requestStatus2;    
       
  6612 
       
  6613     // --- prepare data ---
       
  6614 
       
  6615     CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL();
       
  6616     CleanupStack::PushL(list);
       
  6617 
       
  6618     RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork;
       
  6619     
       
  6620     prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm;
       
  6621     prefNetwork.iCountryCode = _L("262");
       
  6622     prefNetwork.iNetworkId = _L("01");
       
  6623     
       
  6624     list->AddEntryL(prefNetwork);
       
  6625     
       
  6626     TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list);    
       
  6627     listData.SerialiseL(data);
       
  6628     
       
  6629     // Invoke Notify request
       
  6630     
       
  6631     iPhone.NotifyPreferredNetworksListChange(requestStatus);
       
  6632 
       
  6633     // Invoke Notify request for second client
       
  6634     
       
  6635     phone2.NotifyPreferredNetworksListChange(requestStatus2);
       
  6636     
       
  6637     // Invoke Store request
       
  6638         
       
  6639     iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data);
       
  6640     iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone);
       
  6641     
       
  6642     TRequestStatus storeRequestStatus;
       
  6643     iPhone.StorePreferredNetworksListL(storeRequestStatus, list);
       
  6644 
       
  6645     User::WaitForRequest(storeRequestStatus);
       
  6646     ASSERT_EQUALS(KErrNone, storeRequestStatus.Int());    
       
  6647     AssertMockLtsyStatusL();
       
  6648     
       
  6649     User::WaitForRequest(requestStatus);
       
  6650     User::WaitForRequest(requestStatus2);
       
  6651     
       
  6652     ASSERT_EQUALS(KErrNone, requestStatus.Int());
       
  6653     ASSERT_EQUALS(KErrNone, requestStatus2.Int());    
       
  6654 
       
  6655     CleanupStack::PopAndDestroy(5, this); // list, phone2, telServer2, data, this
       
  6656     
       
  6657     }
  6367     }
  6658 
  6368 
  6659 /**
  6369 /**
  6660 @SYMTestCaseID BA-CTSY-NTWC-MNNSSC-0001
  6370 @SYMTestCaseID BA-CTSY-NTWC-MNNSSC-0001
  6661 @SYMPREQ 1551
  6371 @SYMPREQ 1551