5238 OpenPhoneL(); |
5250 OpenPhoneL(); |
5239 |
5251 |
5240 RBuf8 data; |
5252 RBuf8 data; |
5241 CleanupClosePushL(data); |
5253 CleanupClosePushL(data); |
5242 |
5254 |
5243 TRequestStatus requestStatus; |
5255 TRequestStatus requestStatus; |
5244 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
5256 |
5245 CleanupStack::PushL(list); |
5257 // --- prepare data --- |
5246 |
5258 |
|
5259 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5260 CleanupStack::PushL(list); |
|
5261 |
|
5262 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetworks[3]; |
|
5263 |
|
5264 prefNetworks[0].iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5265 prefNetworks[0].iCountryCode = _L("262"); |
|
5266 prefNetworks[0].iNetworkId = _L("01"); |
|
5267 |
|
5268 prefNetworks[1].iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5269 prefNetworks[1].iCountryCode = _L("262"); |
|
5270 prefNetworks[1].iNetworkId = _L("02"); |
|
5271 |
|
5272 prefNetworks[2].iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5273 prefNetworks[2].iCountryCode = _L("262"); |
|
5274 prefNetworks[2].iNetworkId = _L("03"); |
|
5275 |
|
5276 for( TInt i=0; i < 3; ++i ) |
|
5277 { |
|
5278 list->AddEntryL(prefNetworks[i]); |
|
5279 } |
|
5280 |
|
5281 TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list); |
|
5282 listData.SerialiseL(data); |
|
5283 |
|
5284 // Invoke Store request |
|
5285 |
|
5286 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5287 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5288 |
5247 iPhone.StorePreferredNetworksListL(requestStatus, list); |
5289 iPhone.StorePreferredNetworksListL(requestStatus, list); |
5248 |
5290 |
5249 User::WaitForRequest(requestStatus); |
5291 User::WaitForRequest(requestStatus); |
5250 AssertMockLtsyStatusL(); |
5292 AssertMockLtsyStatusL(); |
5251 ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); |
5293 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
5252 |
5294 |
5253 AssertMockLtsyStatusL(); |
5295 CleanupStack::PopAndDestroy(3, this); // list, data, this |
5254 CleanupStack::PopAndDestroy(3, this); // data, this, list |
5296 } |
5255 |
5297 |
5256 } |
5298 /** |
5257 |
5299 @SYMTestCaseID BA-CTSY-NTWC-MSPNL-0001a |
|
5300 @SYMPREQ 417-71654 |
|
5301 @SYMComponent telephony_ctsy |
|
5302 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::StorePreferredNetworksListL with empty list |
|
5303 @SYMTestPriority High |
|
5304 @SYMTestActions 1. Invoke RMobilePhone::StorePreferredNetworksListL with an empty list of Preferred Networks. |
|
5305 @SYMTestExpectedResults LTSY receives an empty list of Preferred Networks. |
|
5306 @SYMTestType CT |
|
5307 */ |
|
5308 void CCTsyNetworkControlFU::TestStorePreferredNetworksListL0001aL() |
|
5309 { |
|
5310 |
|
5311 OpenEtelServerL(EUseExtendedError); |
|
5312 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5313 OpenPhoneL(); |
|
5314 |
|
5315 RBuf8 data; |
|
5316 CleanupClosePushL(data); |
|
5317 |
|
5318 TRequestStatus requestStatus; |
|
5319 |
|
5320 // --- prepare data --- |
|
5321 |
|
5322 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5323 CleanupStack::PushL(list); |
|
5324 |
|
5325 TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list); |
|
5326 listData.SerialiseL(data); |
|
5327 |
|
5328 // Invoke Store request |
|
5329 |
|
5330 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5331 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5332 |
|
5333 iPhone.StorePreferredNetworksListL(requestStatus, list); |
|
5334 |
|
5335 User::WaitForRequest(requestStatus); |
|
5336 AssertMockLtsyStatusL(); |
|
5337 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
5338 |
|
5339 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
5340 } |
|
5341 |
|
5342 /** |
|
5343 @SYMTestCaseID BA-CTSY-NTWC-MSPNL-0001b |
|
5344 @SYMPREQ 417-71654 |
|
5345 @SYMComponent telephony_ctsy |
|
5346 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::StorePreferredNetworksListL |
|
5347 with error and with duplicate LTSY complete message |
|
5348 @SYMTestPriority High |
|
5349 @SYMTestActions 1. Invoke RMobilePhone::StorePreferredNetworksListL. |
|
5350 2. LTSY returns error. |
|
5351 3. 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 |
|
5357 */ |
|
5358 void CCTsyNetworkControlFU::TestStorePreferredNetworksListL0001bL() |
|
5359 { |
|
5360 |
|
5361 OpenEtelServerL(EUseExtendedError); |
|
5362 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5363 OpenPhoneL(); |
|
5364 |
|
5365 RBuf8 data; |
|
5366 CleanupClosePushL(data); |
|
5367 |
|
5368 TRequestStatus requestStatus; |
|
5369 |
|
5370 // --- prepare data --- |
|
5371 |
|
5372 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5373 CleanupStack::PushL(list); |
|
5374 |
|
5375 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork; |
|
5376 |
|
5377 prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5378 prefNetwork.iCountryCode = _L("262"); |
|
5379 prefNetwork.iNetworkId = _L("01"); |
|
5380 |
|
5381 list->AddEntryL(prefNetwork); |
|
5382 |
|
5383 TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list); |
|
5384 listData.SerialiseL(data); |
|
5385 |
|
5386 // Invoke Store request - LTSY returns KErrUnknown |
|
5387 |
|
5388 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5389 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrUnknown); |
|
5390 |
|
5391 iPhone.StorePreferredNetworksListL(requestStatus, list); |
|
5392 |
|
5393 User::WaitForRequest(requestStatus); |
|
5394 AssertMockLtsyStatusL(); |
|
5395 ASSERT_EQUALS(KErrUnknown, requestStatus.Int()); |
|
5396 |
|
5397 // Invoke Store request - LTSY returns duplicate complete messages with KErrNone |
|
5398 |
|
5399 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5400 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5401 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5402 |
|
5403 iPhone.StorePreferredNetworksListL(requestStatus, list); |
|
5404 |
|
5405 User::WaitForRequest(requestStatus); |
|
5406 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()); |
|
5418 |
|
5419 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
5420 } |
|
5421 |
|
5422 /** |
|
5423 @SYMTestCaseID BA-CTSY-NTWC-MSPNL-0002 |
|
5424 @SYMPREQ 417-71654 |
|
5425 @SYMComponent telephony_ctsy |
|
5426 @SYMTestCaseDesc Test support in CTSY for Cancelling RMobilePhone::StorePreferredNetworksListL |
|
5427 @SYMTestPriority High |
|
5428 @SYMTestActions 1. Invoke RMobilePhone::StorePreferredNetworksListL. |
|
5429 2. Cancel the outstanding request. |
|
5430 3. LTSY ignores cancelling the request and stores the preferred networks list. |
|
5431 @SYMTestExpectedResults Request status of the operation is KErrNone. |
|
5432 @SYMTestType CT |
|
5433 */ |
|
5434 void CCTsyNetworkControlFU::TestStorePreferredNetworksListL0002L() |
|
5435 { |
|
5436 |
|
5437 OpenEtelServerL(EUseExtendedError); |
|
5438 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5439 OpenPhoneL(); |
|
5440 |
|
5441 RBuf8 data; |
|
5442 CleanupClosePushL(data); |
|
5443 |
|
5444 TRequestStatus requestStatus; |
|
5445 |
|
5446 // --- prepare data --- |
|
5447 |
|
5448 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5449 CleanupStack::PushL(list); |
|
5450 |
|
5451 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork; |
|
5452 |
|
5453 prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5454 prefNetwork.iCountryCode = _L("262"); |
|
5455 prefNetwork.iNetworkId = _L("01"); |
|
5456 |
|
5457 list->AddEntryL(prefNetwork); |
|
5458 |
|
5459 TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list); |
|
5460 listData.SerialiseL(data); |
|
5461 |
|
5462 // Invoke Store request |
|
5463 |
|
5464 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5465 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5466 |
|
5467 iPhone.StorePreferredNetworksListL(requestStatus, list); |
|
5468 |
|
5469 // Cancel outstanding request |
|
5470 iPhone.CancelAsyncRequest(EMobilePhoneStorePreferredNetworksList); |
|
5471 |
|
5472 User::WaitForRequest(requestStatus); |
|
5473 AssertMockLtsyStatusL(); |
|
5474 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
5475 |
|
5476 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 |
|
5556 } |
|
5557 |
|
5558 /** |
|
5559 @SYMTestCaseID BA-CTSY-NTWC-CRMPPN-0001 |
|
5560 @SYMPREQ 417-71654 |
|
5561 @SYMComponent telephony_ctsy |
|
5562 @SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhonePreferredNetworks::Start |
|
5563 @SYMTestPriority High |
|
5564 @SYMTestActions 1. Invoke CRetrieveMobilePhonePreferredNetworks::Start. |
|
5565 2. Add a new entry to the list. |
|
5566 3. Invoke RMobilePhone::StorePreferredNetworksListL. |
|
5567 @SYMTestExpectedResults LTSY receives the modified list and test code receives KErrNone. |
|
5568 @SYMTestType CT |
|
5569 */ |
|
5570 void CCTsyNetworkControlFU::TestRetrieveMobilePhonePreferredNetworks0001L() |
|
5571 { |
|
5572 |
|
5573 OpenEtelServerL(EUseExtendedError); |
|
5574 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5575 OpenPhoneL(); |
|
5576 |
|
5577 RBuf8 data; |
|
5578 CleanupClosePushL(data); |
|
5579 |
|
5580 // --- prepare data --- |
|
5581 |
|
5582 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5583 CleanupStack::PushL(list); |
|
5584 |
|
5585 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork; |
|
5586 |
|
5587 prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5588 prefNetwork.iCountryCode = _L("262"); |
|
5589 prefNetwork.iNetworkId = _L("01"); |
|
5590 |
|
5591 list->AddEntryL(prefNetwork); |
|
5592 |
|
5593 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData(list); |
|
5594 completeLtsyData.SerialiseL(data); |
|
5595 |
|
5596 CFilteringActiveScheduler scheduler; |
|
5597 CActiveScheduler::Install(&scheduler); |
|
5598 |
|
5599 CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks = |
|
5600 CRetrieveMobilePhonePreferredNetworks::NewL(iPhone); |
|
5601 CleanupStack::PushL(retrieveMobilePhonePreferredNetworks); |
|
5602 |
|
5603 CActiveRetriever::ResetRequestsNumber(); |
|
5604 CActiveRetriever* activeRetriever = |
|
5605 CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks); |
|
5606 CleanupStack::PushL(activeRetriever); |
|
5607 scheduler.AddRetrieverL(*activeRetriever); |
|
5608 |
|
5609 // Invoke retrieve request |
|
5610 |
|
5611 iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq); |
|
5612 iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrNone, data); |
|
5613 |
|
5614 retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status()); |
|
5615 |
|
5616 activeRetriever->Activate(); |
|
5617 scheduler.StartScheduler(); |
|
5618 |
|
5619 AssertMockLtsyStatusL(); |
|
5620 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
5621 ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int()); |
|
5622 |
|
5623 CMobilePhoneStoredNetworkList* retrievedList = |
|
5624 retrieveMobilePhonePreferredNetworks->RetrieveListL(); |
|
5625 CleanupStack::PushL( retrievedList ); |
|
5626 |
|
5627 // Check Retrieved list |
|
5628 |
|
5629 ASSERT_EQUALS(list->Enumerate(), retrievedList->Enumerate()); |
|
5630 ASSERT_EQUALS(list->GetEntryL(0).iAccess, retrievedList->GetEntryL(0).iAccess); |
|
5631 ASSERT_EQUALS(list->GetEntryL(0).iCountryCode, retrievedList->GetEntryL(0).iCountryCode); |
|
5632 ASSERT_EQUALS(list->GetEntryL(0).iNetworkId, retrievedList->GetEntryL(0).iNetworkId); |
|
5633 |
|
5634 CleanupStack::PopAndDestroy(3, |
|
5635 retrieveMobilePhonePreferredNetworks); // retrievedList |
|
5636 // activeRetriever |
|
5637 // retrieveMobilePhonePreferredNetworks |
|
5638 |
|
5639 CActiveScheduler::Install(NULL); |
|
5640 |
|
5641 // Add new entry to the list |
|
5642 |
|
5643 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork2; |
|
5644 prefNetwork2.iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5645 prefNetwork2.iCountryCode = _L("262"); |
|
5646 prefNetwork2.iNetworkId = _L("02"); |
|
5647 |
|
5648 list->AddEntryL(prefNetwork2); |
|
5649 |
|
5650 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData2(list); |
|
5651 completeLtsyData2.SerialiseL(data); |
|
5652 |
|
5653 // Invoke Store request |
|
5654 |
|
5655 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5656 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5657 |
|
5658 TRequestStatus requestStatus; |
|
5659 iPhone.StorePreferredNetworksListL(requestStatus, list); |
|
5660 |
|
5661 User::WaitForRequest(requestStatus); |
|
5662 |
|
5663 AssertMockLtsyStatusL(); |
|
5664 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
5665 |
|
5666 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
5667 |
|
5668 } |
|
5669 |
|
5670 /** |
|
5671 @SYMTestCaseID BA-CTSY-NTWC-CRMPPN-0001a |
|
5672 @SYMPREQ 417-71654 |
|
5673 @SYMComponent telephony_ctsy |
|
5674 @SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhonePreferredNetworks::Start |
|
5675 @SYMTestPriority High |
|
5676 @SYMTestActions 1. Invoke CRetrieveMobilePhonePreferredNetworks::Start. |
|
5677 2. Remove an entry from the list. |
|
5678 3. Invoke RMobilePhone::StorePreferredNetworksListL. |
|
5679 @SYMTestExpectedResults LTSY receives the modified list and test code receives KErrNone. |
|
5680 @SYMTestType CT |
|
5681 */ |
|
5682 void CCTsyNetworkControlFU::TestRetrieveMobilePhonePreferredNetworks0001aL() |
|
5683 { |
|
5684 |
|
5685 OpenEtelServerL(EUseExtendedError); |
|
5686 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5687 OpenPhoneL(); |
|
5688 |
|
5689 RBuf8 data; |
|
5690 CleanupClosePushL(data); |
|
5691 |
|
5692 // --- prepare data --- |
|
5693 |
|
5694 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5695 CleanupStack::PushL(list); |
|
5696 |
|
5697 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetworks[2]; |
|
5698 |
|
5699 prefNetworks[0].iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5700 prefNetworks[0].iCountryCode = _L("262"); |
|
5701 prefNetworks[0].iNetworkId = _L("01"); |
|
5702 |
|
5703 prefNetworks[1].iAccess = RMobilePhone::KNetworkAccessGsm; |
|
5704 prefNetworks[1].iCountryCode = _L("262"); |
|
5705 prefNetworks[1].iNetworkId = _L("02"); |
|
5706 |
|
5707 for (int i = 0; i < 2; ++i) |
|
5708 { |
|
5709 list->AddEntryL(prefNetworks[i]); |
|
5710 } |
|
5711 |
|
5712 CFilteringActiveScheduler scheduler; |
|
5713 CActiveScheduler::Install(&scheduler); |
|
5714 |
|
5715 CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks = |
|
5716 CRetrieveMobilePhonePreferredNetworks::NewL(iPhone); |
|
5717 CleanupStack::PushL(retrieveMobilePhonePreferredNetworks); |
|
5718 |
|
5719 CActiveRetriever::ResetRequestsNumber(); |
|
5720 CActiveRetriever* activeRetriever = |
|
5721 CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks); |
|
5722 CleanupStack::PushL(activeRetriever); |
|
5723 scheduler.AddRetrieverL(*activeRetriever); |
|
5724 |
|
5725 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData(list); |
|
5726 completeLtsyData.SerialiseL(data); |
|
5727 |
|
5728 // Invoke Retrieve request |
|
5729 |
|
5730 iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq); |
|
5731 iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrNone, data); |
|
5732 |
|
5733 retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status()); |
|
5734 activeRetriever->Activate(); |
|
5735 scheduler.StartScheduler(); |
|
5736 |
|
5737 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
5738 ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int()); |
|
5739 AssertMockLtsyStatusL(); |
|
5740 |
|
5741 CMobilePhoneStoredNetworkList* retrievedList = |
|
5742 retrieveMobilePhonePreferredNetworks->RetrieveListL(); |
|
5743 CleanupStack::PushL( retrievedList ); |
|
5744 |
|
5745 // Check retrieved list |
|
5746 |
|
5747 ASSERT_EQUALS(list->Enumerate(), retrievedList->Enumerate()); |
|
5748 ASSERT_EQUALS(list->GetEntryL(0).iAccess, retrievedList->GetEntryL(0).iAccess); |
|
5749 ASSERT_EQUALS(list->GetEntryL(0).iCountryCode, retrievedList->GetEntryL(0).iCountryCode); |
|
5750 ASSERT_EQUALS(list->GetEntryL(0).iNetworkId, retrievedList->GetEntryL(0).iNetworkId); |
|
5751 ASSERT_EQUALS(list->GetEntryL(1).iAccess, retrievedList->GetEntryL(1).iAccess); |
|
5752 ASSERT_EQUALS(list->GetEntryL(1).iCountryCode, retrievedList->GetEntryL(1).iCountryCode); |
|
5753 ASSERT_EQUALS(list->GetEntryL(1).iNetworkId, retrievedList->GetEntryL(1).iNetworkId); |
|
5754 |
|
5755 CleanupStack::PopAndDestroy(3, |
|
5756 retrieveMobilePhonePreferredNetworks); // retrievedList |
|
5757 // activeRetriever |
|
5758 // retrieveMobilePhonePreferredNetworks |
|
5759 |
|
5760 CActiveScheduler::Install(NULL); |
|
5761 |
|
5762 // Remove the last entry from the list |
|
5763 |
|
5764 list->DeleteEntryL(1); |
|
5765 |
|
5766 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData2(list); |
|
5767 completeLtsyData2.SerialiseL(data); |
|
5768 |
|
5769 // Invoke Store request |
|
5770 |
|
5771 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
5772 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
5773 |
|
5774 TRequestStatus requestStatus; |
|
5775 iPhone.StorePreferredNetworksListL(requestStatus, list); |
|
5776 |
|
5777 User::WaitForRequest(requestStatus); |
|
5778 AssertMockLtsyStatusL(); |
|
5779 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
5780 |
|
5781 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
5782 |
|
5783 } |
|
5784 |
|
5785 /** |
|
5786 @SYMTestCaseID BA-CTSY-NTWC-CRMPPN-0001b |
|
5787 @SYMPREQ 417-71654 |
|
5788 @SYMComponent telephony_ctsy |
|
5789 @SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhonePreferredNetworks::Start with empty list |
|
5790 @SYMTestPriority High |
|
5791 @SYMTestActions 1. Invoke CRetrieveMobilePhonePreferredNetworks::Start. |
|
5792 2. LTSY returns an empty list of preferred networks. |
|
5793 @SYMTestExpectedResults Test code receives an empty list of preferred networks. |
|
5794 @SYMTestType CT |
|
5795 */ |
|
5796 void CCTsyNetworkControlFU::TestRetrieveMobilePhonePreferredNetworks0001bL() |
|
5797 { |
|
5798 |
|
5799 OpenEtelServerL(EUseExtendedError); |
|
5800 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5801 OpenPhoneL(); |
|
5802 |
|
5803 RBuf8 data; |
|
5804 CleanupClosePushL(data); |
|
5805 |
|
5806 // --- prepare data --- |
|
5807 |
|
5808 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5809 CleanupStack::PushL(list); |
|
5810 |
|
5811 CFilteringActiveScheduler scheduler; |
|
5812 CActiveScheduler::Install(&scheduler); |
|
5813 |
|
5814 CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks = |
|
5815 CRetrieveMobilePhonePreferredNetworks::NewL(iPhone); |
|
5816 CleanupStack::PushL(retrieveMobilePhonePreferredNetworks); |
|
5817 |
|
5818 CActiveRetriever::ResetRequestsNumber(); |
|
5819 CActiveRetriever* activeRetriever = |
|
5820 CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks); |
|
5821 CleanupStack::PushL(activeRetriever); |
|
5822 scheduler.AddRetrieverL(*activeRetriever); |
|
5823 |
|
5824 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData(list); |
|
5825 completeLtsyData.SerialiseL(data); |
|
5826 |
|
5827 // Invoke Retrieve request |
|
5828 |
|
5829 iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq); |
|
5830 iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrNone, data); |
|
5831 |
|
5832 retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status()); |
|
5833 activeRetriever->Activate(); |
|
5834 scheduler.StartScheduler(); |
|
5835 |
|
5836 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
5837 ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int()); |
|
5838 AssertMockLtsyStatusL(); |
|
5839 |
|
5840 CMobilePhoneStoredNetworkList* retrievedList = |
|
5841 retrieveMobilePhonePreferredNetworks->RetrieveListL(); |
|
5842 CleanupStack::PushL( retrievedList ); |
|
5843 |
|
5844 // Check retrieved list is empty |
|
5845 |
|
5846 ASSERT_EQUALS(list->Enumerate(), retrievedList->Enumerate()); |
|
5847 |
|
5848 CleanupStack::PopAndDestroy(3, |
|
5849 retrieveMobilePhonePreferredNetworks); // retrievedList |
|
5850 // activeRetriever |
|
5851 // retrieveMobilePhonePreferredNetworks |
|
5852 |
|
5853 CActiveScheduler::Install(NULL); |
|
5854 |
|
5855 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
5856 |
|
5857 } |
|
5858 |
|
5859 /** |
|
5860 @SYMTestCaseID BA-CTSY-NTWC-CRMPPN-0001c |
|
5861 @SYMPREQ 417-71654 |
|
5862 @SYMComponent telephony_ctsy |
|
5863 @SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhonePreferredNetworks::Start with error |
|
5864 @SYMTestPriority High |
|
5865 @SYMTestActions 1. Invoke CRetrieveMobilePhonePreferredNetworks::Start. |
|
5866 2. LTSY returns error. |
|
5867 @SYMTestExpectedResults Test code receives error. |
|
5868 @SYMTestType CT |
|
5869 */ |
|
5870 void CCTsyNetworkControlFU::TestRetrieveMobilePhonePreferredNetworks0001cL() |
|
5871 { |
|
5872 |
|
5873 OpenEtelServerL(EUseExtendedError); |
|
5874 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5875 OpenPhoneL(); |
|
5876 |
|
5877 RBuf8 data; |
|
5878 CleanupClosePushL(data); |
|
5879 |
|
5880 // --- prepare data --- |
|
5881 |
|
5882 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5883 CleanupStack::PushL(list); |
|
5884 |
|
5885 CFilteringActiveScheduler scheduler; |
|
5886 CActiveScheduler::Install(&scheduler); |
|
5887 |
|
5888 CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks = |
|
5889 CRetrieveMobilePhonePreferredNetworks::NewL(iPhone); |
|
5890 CleanupStack::PushL(retrieveMobilePhonePreferredNetworks); |
|
5891 |
|
5892 CActiveRetriever::ResetRequestsNumber(); |
|
5893 CActiveRetriever* activeRetriever = |
|
5894 CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks); |
|
5895 CleanupStack::PushL(activeRetriever); |
|
5896 scheduler.AddRetrieverL(*activeRetriever); |
|
5897 |
|
5898 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData(list); |
|
5899 completeLtsyData.SerialiseL(data); |
|
5900 |
|
5901 // Invoke Retrieve request - LTSY returns KErrUnknown |
|
5902 |
|
5903 iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq); |
|
5904 iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrUnknown, data); |
|
5905 |
|
5906 retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status()); |
|
5907 activeRetriever->Activate(); |
|
5908 scheduler.StartScheduler(); |
|
5909 |
|
5910 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
5911 ASSERT_EQUALS(KErrUnknown, activeRetriever->iStatus.Int()); |
|
5912 AssertMockLtsyStatusL(); |
|
5913 |
|
5914 // Invoke Retrieve request - LTSY returns KErrNotSupported |
|
5915 |
|
5916 iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq, KErrNotSupported); |
|
5917 |
|
5918 retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status()); |
|
5919 activeRetriever->Activate(); |
|
5920 scheduler.StartScheduler(); |
|
5921 |
|
5922 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
5923 ASSERT_EQUALS(KErrNotSupported, activeRetriever->iStatus.Int()); |
|
5924 AssertMockLtsyStatusL(); |
|
5925 |
|
5926 CleanupStack::PopAndDestroy(2, |
|
5927 retrieveMobilePhonePreferredNetworks); // activeRetriever |
|
5928 // retrieveMobilePhonePreferredNetworks |
|
5929 |
|
5930 CActiveScheduler::Install(NULL); |
|
5931 |
|
5932 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
5933 |
|
5934 } |
|
5935 |
|
5936 /** |
|
5937 @SYMTestCaseID BA-CTSY-NTWC-CRMPPN-0002 |
|
5938 @SYMPREQ 417-71654 |
|
5939 @SYMComponent telephony_ctsy |
|
5940 @SYMTestCaseDesc Test support in CTSY for Cancelling CRetrieveMobilePhonePreferredNetworks::Start |
|
5941 @SYMTestPriority High |
|
5942 @SYMTestActions 1. Invoke CRetrieveMobilePhonePreferredNetworks::Start. |
|
5943 2. Cancel outstanding request. |
|
5944 @SYMTestExpectedResults Request status of the operation is KErrCancel |
|
5945 @SYMTestType CT |
|
5946 */ |
|
5947 void CCTsyNetworkControlFU::TestRetrieveMobilePhonePreferredNetworks0002L() |
|
5948 { |
|
5949 OpenEtelServerL(EUseExtendedError); |
|
5950 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
5951 OpenPhoneL(); |
|
5952 |
|
5953 RBuf8 data; |
|
5954 CleanupClosePushL(data); |
|
5955 |
|
5956 // --- prepare data --- |
|
5957 |
|
5958 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
5959 CleanupStack::PushL(list); |
|
5960 |
|
5961 CFilteringActiveScheduler scheduler; |
|
5962 CActiveScheduler::Install(&scheduler); |
|
5963 |
|
5964 CRetrieveMobilePhonePreferredNetworks* retrieveMobilePhonePreferredNetworks = |
|
5965 CRetrieveMobilePhonePreferredNetworks::NewL(iPhone); |
|
5966 CleanupStack::PushL(retrieveMobilePhonePreferredNetworks); |
|
5967 |
|
5968 CActiveRetriever::ResetRequestsNumber(); |
|
5969 CActiveRetriever* activeRetriever = |
|
5970 CActiveRetriever::NewL(*retrieveMobilePhonePreferredNetworks); |
|
5971 CleanupStack::PushL(activeRetriever); |
|
5972 scheduler.AddRetrieverL(*activeRetriever); |
|
5973 |
|
5974 TMockLtsyData1<CMobilePhoneStoredNetworkList*> completeLtsyData(list); |
|
5975 completeLtsyData.SerialiseL(data); |
|
5976 |
|
5977 // Invoke Retrieve request |
|
5978 |
|
5979 TRequestStatus mockLtsyStatus; |
|
5980 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
5981 iMockLTSY.ExpectL(ECtsyPhoneGetPreferredNetworksReq); |
|
5982 iMockLTSY.CompleteL(ECtsyPhoneGetPreferredNetworksComp, KErrNone, data); |
|
5983 |
|
5984 retrieveMobilePhonePreferredNetworks->Start(activeRetriever->Status()); |
|
5985 activeRetriever->Activate(); |
|
5986 |
|
5987 // Cancel Retrieve request |
|
5988 |
|
5989 iPhone.CancelAsyncRequest(EMobilePhoneGetPreferredNetworksPhase1); |
|
5990 scheduler.StartScheduler(); |
|
5991 |
|
5992 User::WaitForRequest(mockLtsyStatus); |
|
5993 |
|
5994 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
5995 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
5996 ASSERT_EQUALS(KErrCancel, activeRetriever->iStatus.Int()); |
|
5997 AssertMockLtsyStatusL(); |
|
5998 |
|
5999 CleanupStack::PopAndDestroy(2, |
|
6000 retrieveMobilePhonePreferredNetworks); // activeRetriever |
|
6001 // retrieveMobilePhonePreferredNetworks |
|
6002 |
|
6003 CActiveScheduler::Install(NULL); |
|
6004 |
|
6005 CleanupStack::PopAndDestroy(3, this); // list, data, this |
|
6006 |
|
6007 } |
|
6008 |
|
6009 /** |
|
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 } |
5258 |
6107 |
5259 /** |
6108 /** |
5260 @SYMTestCaseID BA-CTSY-NTWC-MGNRS-0001 |
6109 @SYMTestCaseID BA-CTSY-NTWC-MGNRS-0001 |
5261 @SYMPREQ 1551 |
6110 @SYMPREQ 1551 |
5262 @SYMCR 1595 |
6111 @SYMCR 1595 |
5571 ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); |
6420 ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); |
5572 |
6421 |
5573 CleanupStack::PopAndDestroy(2, this); // data, this |
6422 CleanupStack::PopAndDestroy(2, this); // data, this |
5574 |
6423 |
5575 } |
6424 } |
5576 /** |
6425 |
5577 @SYMTestCaseID BA-CTSY-NTWC-MNPNLC-0001 |
6426 /** |
5578 @SYMPREQ 1551 |
6427 @SYMTestCaseID BA-CTSY-NTWC-MNPNLC-0001 |
5579 @SYMComponent telephony_ctsy |
6428 @SYMPREQ 417-71654 |
5580 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyPreferredNetworksListChange |
6429 @SYMComponent telephony_ctsy |
5581 @SYMTestPriority High |
6430 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyPreferredNetworksListChange |
5582 @SYMTestActions Invokes RMobilePhone::NotifyPreferredNetworksListChange |
6431 @SYMTestPriority High |
5583 @SYMTestExpectedResults Pass |
6432 @SYMTestActions 1. Invoke RMobilePhone::NotifyPreferredNetworksListChange. |
5584 @SYMTestType CT |
6433 2. Invoke RMobilePhone::StorePreferredNetworksListL. |
|
6434 @SYMTestExpectedResults Test code receives preferred network list notification |
|
6435 @SYMTestType CT |
5585 */ |
6436 */ |
5586 void CCTsyNetworkControlFU::TestNotifyPreferredNetworksListChange0001L() |
6437 void CCTsyNetworkControlFU::TestNotifyPreferredNetworksListChange0001L() |
5587 { |
6438 { |
5588 |
6439 |
5589 OpenEtelServerL(EUseExtendedError); |
6440 OpenEtelServerL(EUseExtendedError); |
5590 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
6441 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
5591 OpenPhoneL(); |
6442 OpenPhoneL(); |
5592 |
6443 |
5593 RBuf8 data; |
6444 RBuf8 data; |
5594 CleanupClosePushL(data); |
6445 CleanupClosePushL(data); |
5595 |
6446 |
5596 TRequestStatus requestStatus; |
6447 TRequestStatus requestStatus; |
|
6448 |
|
6449 // --- prepare data --- |
|
6450 |
|
6451 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
6452 CleanupStack::PushL(list); |
|
6453 |
|
6454 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork; |
|
6455 |
|
6456 prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm; |
|
6457 prefNetwork.iCountryCode = _L("262"); |
|
6458 prefNetwork.iNetworkId = _L("01"); |
|
6459 |
|
6460 list->AddEntryL(prefNetwork); |
|
6461 |
|
6462 TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list); |
|
6463 listData.SerialiseL(data); |
|
6464 |
|
6465 // Invoke Notify request |
5597 |
6466 |
5598 iPhone.NotifyPreferredNetworksListChange(requestStatus); |
6467 iPhone.NotifyPreferredNetworksListChange(requestStatus); |
5599 |
6468 |
|
6469 // Invoke Store request |
|
6470 |
|
6471 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
6472 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
6473 |
|
6474 TRequestStatus storeRequestStatus; |
|
6475 iPhone.StorePreferredNetworksListL(storeRequestStatus, list); |
|
6476 |
|
6477 User::WaitForRequest(storeRequestStatus); |
|
6478 ASSERT_EQUALS(KErrNone, storeRequestStatus.Int()); |
|
6479 AssertMockLtsyStatusL(); |
|
6480 |
5600 User::WaitForRequest(requestStatus); |
6481 User::WaitForRequest(requestStatus); |
5601 AssertMockLtsyStatusL(); |
6482 |
5602 ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); |
6483 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
5603 |
6484 |
5604 CleanupStack::PopAndDestroy(2, this); // data, this |
6485 CleanupStack::PopAndDestroy(3, this); // list, data, this |
5605 |
6486 |
5606 } |
6487 } |
5607 |
6488 |
|
6489 /** |
|
6490 @SYMTestCaseID BA-CTSY-NTWC-MNPNLC-0002 |
|
6491 @SYMPREQ 417-71654 |
|
6492 @SYMComponent telephony_ctsy |
|
6493 @SYMTestCaseDesc Test support in CTSY for Cancelling RMobilePhone::NotifyPreferredNetworksListChange |
|
6494 @SYMTestPriority High |
|
6495 @SYMTestActions 1. Invoke RMobilePhone::NotifyPreferredNetworksListChange. |
|
6496 2. Cancel subscription to preferred network list change. |
|
6497 3. Invoke RMobilePhone::StorePreferredNetworksListL. |
|
6498 @SYMTestExpectedResults Test code does not receive preferred network list notification |
|
6499 @SYMTestType CT |
|
6500 */ |
|
6501 void CCTsyNetworkControlFU::TestNotifyPreferredNetworksListChange0002L() |
|
6502 { |
|
6503 |
|
6504 OpenEtelServerL(EUseExtendedError); |
|
6505 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
6506 OpenPhoneL(); |
|
6507 |
|
6508 RBuf8 data; |
|
6509 CleanupClosePushL(data); |
|
6510 |
|
6511 TRequestStatus requestStatus; |
|
6512 |
|
6513 // --- prepare data --- |
|
6514 |
|
6515 CMobilePhoneStoredNetworkList* list = CMobilePhoneStoredNetworkList::NewL(); |
|
6516 CleanupStack::PushL(list); |
|
6517 |
|
6518 RMobilePhone::TMobilePreferredNetworkEntryV3 prefNetwork; |
|
6519 |
|
6520 prefNetwork.iAccess = RMobilePhone::KNetworkAccessGsm; |
|
6521 prefNetwork.iCountryCode = _L("262"); |
|
6522 prefNetwork.iNetworkId = _L("01"); |
|
6523 |
|
6524 list->AddEntryL(prefNetwork); |
|
6525 |
|
6526 TMockLtsyData1<CMobilePhoneStoredNetworkList*> listData(list); |
|
6527 listData.SerialiseL(data); |
|
6528 |
|
6529 // Invoke Notify request |
|
6530 |
|
6531 iPhone.NotifyPreferredNetworksListChange(requestStatus); |
|
6532 |
|
6533 // Cancel Notify request |
|
6534 |
|
6535 iPhone.CancelAsyncRequest(EMobilePhoneNotifyStorePreferredNetworksListChange); |
|
6536 |
|
6537 TRequestStatus mockLtsyStatus; |
|
6538 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
6539 |
|
6540 User::WaitForRequest(requestStatus); |
|
6541 AssertMockLtsyStatusL(); |
|
6542 ASSERT_EQUALS(KErrCancel, requestStatus.Int()); |
|
6543 |
|
6544 // Invoke Store request |
|
6545 |
|
6546 iMockLTSY.ExpectL(ECtsyPhoneStorePreferredNetworksListReq, data); |
|
6547 iMockLTSY.CompleteL(ECtsyPhoneStorePreferredNetworksListComp, KErrNone); |
|
6548 |
|
6549 TRequestStatus storeRequestStatus; |
|
6550 iPhone.StorePreferredNetworksListL(storeRequestStatus, list); |
|
6551 |
|
6552 User::WaitForRequest(mockLtsyStatus); |
|
6553 AssertMockLtsyStatusL(); |
|
6554 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
6555 |
|
6556 User::WaitForRequest(storeRequestStatus); |
|
6557 AssertMockLtsyStatusL(); |
|
6558 ASSERT_EQUALS(KErrNone, storeRequestStatus.Int()); |
|
6559 |
|
6560 // Start timer and check if any notification is received |
|
6561 |
|
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()); |
|
6572 |
|
6573 CleanupStack::PopAndDestroy(4, this); // timer, list, data, this |
|
6574 |
|
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 } |
5608 |
6658 |
5609 /** |
6659 /** |
5610 @SYMTestCaseID BA-CTSY-NTWC-MNNSSC-0001 |
6660 @SYMTestCaseID BA-CTSY-NTWC-MNNSSC-0001 |
5611 @SYMPREQ 1551 |
6661 @SYMPREQ 1551 |
5612 @SYMComponent telephony_ctsy |
6662 @SYMComponent telephony_ctsy |