1 // Copyright (c) 2008-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 // This file contains implementations of the RConnectionUpsStep classes that test the

    15 // IP Networking User Prompting Functionality added in PREQ1116.

    16 // Each class encapsulates a complete test case and is derived from TE_RConnectionUpsStep

    17 //

    18 //

    19 

    20 /**

    21  @file 

    22 */

    23 

    24 #include "TE_RConnectionUpsTestSteps.h"

    25 #include <test/upstestnotifierproperties.h>

    26 #include <comms-infras/esocktestutils.h>

    27 #include <test/es_dummy.h>

    28 

    29 // Location of DummyNif in Network Table in rconnectionudp.xml

    30 const TInt KDummyNifNetworkId = 3;

    31 

    32 

    33 enum TVerdict TE_RConnectionUPSCloseInterfaces::doTestStepPreambleL()

    34 {

    35 	return EPass;

    36 }

    37 

    38 enum TVerdict TE_RConnectionUPSCloseInterfaces::doTestStepPostambleL()

    39 {

    40 	return EPass;

    41 }

    42 

    43 TE_RConnectionUPSCloseInterfaces::~TE_RConnectionUPSCloseInterfaces()

    44 {

    45 }

    46 

    47 enum TVerdict TE_RConnectionUPSCloseInterfaces::doTestStepL(void)

    48 /**

    49  * This test step results in any open interfaces being stopped.

    50  * The test step is usually invoked after every test case, when ESOCK needs

    51  * to be shut down and restarted. Running this step speeds up the ESOCK

    52  * shutdown process.

    53  */

    54 {

    55 	RSocketServ ss;

    56 	

    57 	ss.Connect();

    58 	CleanupClosePushL(ss);

    59 	

    60 	TInt ret = KErrNone;

    61 	if (KErrNone != WaitForAllInterfacesToCloseL(ss))

    62 		{

    63 		INFO_PRINTF1(_L("Previous test case has left connections up that have not closed. Stopping them."));

    64 		TBuf<200> errDesc;

    65 		if ((ret = ESockTestUtils::StopAllInterfaces(errDesc)) != KErrNone)

    66 			{

    67 			INFO_PRINTF3(_L("StopAllInterfaces() ret=%d\n%S"), ret, &errDesc);

    68 			}			

    69 		}

    70 	ss.Close();

    71 	CleanupStack::Pop();

    72 	

    73 	if (ret != KErrNone)

    74 			{

    75 			return EFail;

    76 			}

    77 	

    78 	return EPass;

    79 }

    80 

    81 

    82 enum TVerdict TE_RConnectionUPSSetNotifFileOverride::doTestStepPreambleL()

    83 {

    84 	return EPass;

    85 }

    86 

    87 enum TVerdict TE_RConnectionUPSSetNotifFileOverride::doTestStepPostambleL()

    88 {

    89 	return EPass;

    90 }

    91 

    92 TE_RConnectionUPSSetNotifFileOverride::~TE_RConnectionUPSSetNotifFileOverride()

    93 {

    94 }

    95 

    96 enum TVerdict TE_RConnectionUPSSetNotifFileOverride::doTestStepL(void)

    97 /**

    98  * This test step is used set a P&S property which causes 

    99  * the UPS test Notifier to override any setting which is 

   100  * has fetched from its configuration file, with the P&S

   101  * values set by this test harness.

   102  *

   103  * This test step is necessary to enable running of this

   104  * test harness in regression test environments where a

   105  * UPS test notifier config file is present.

   106  */

   107 

   108 {

   109 	User::LeaveIfError(RProperty::Set(KUidPSUPSTestNotifCategory, KUtFileOverride, KFileOverride));

   110 	return EPass;

   111 }

   112 

   113 

   114 enum TVerdict TE_RConnectionUPSUnsetNotifFileOverride::doTestStepPreambleL()

   115 {

   116 	return EPass;

   117 }

   118 

   119 enum TVerdict TE_RConnectionUPSUnsetNotifFileOverride::doTestStepPostambleL()

   120 {

   121 	return EPass;

   122 }

   123 

   124 TE_RConnectionUPSUnsetNotifFileOverride::~TE_RConnectionUPSUnsetNotifFileOverride()

   125 {

   126 }

   127 

   128 enum TVerdict TE_RConnectionUPSUnsetNotifFileOverride::doTestStepL(void)

   129 /**

   130  * This test step is used to unset a P&S property which causes 

   131  * the UPS test Notifier to override any setting which is 

   132  * has fetched from its configuration file, with the P&S

   133  * values set by this test harness.

   134  *

   135  * This test step results in the UPS test notifier using settings

   136  * from its configuration file, if one is present

   137  */

   138 {

   139 	User::LeaveIfError(RProperty::Set(KUidPSUPSTestNotifCategory, KUtFileOverride, KNoFileOverride));

   140 	return EPass;

   141 }

   142 

   143 

   144 

   145 /*************************************

   146  *                                   *

   147  *      Implicit API Call Tests      *

   148  *                                   *

   149  *************************************/

   150 

   151 TE_RConnectionUPSTest1a::~TE_RConnectionUPSTest1a()

   152 {

   153 }

   154 

   155 enum TVerdict TE_RConnectionUPSTest1a::doTestStepL(void)

   156 /**

   157  * Test prompting behaviour when calling:

   158  * Implicit RSocket::Connect() on a TCP socket

   159  */

   160 {	

   161 	TInt err;

   162 

   163 	//Delete entries in the DecisionDB

   164 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   165 	

   166 	RSocketServ ss;

   167 	RSocket sock;

   168 		

   169 	err = OpenSocketServer(ss);

   170 	TESTEL(KErrNone == err, err);

   171 	CleanupClosePushL(ss);

   172 

   173 	err = OpenTcpSocket(sock, ss);

   174 	TESTEL(KErrNone == err, err);

   175 	CleanupClosePushL(sock);

   176 

   177 	//Get the NotifyCount before the RSocket::...() API is called

   178 	TInt notifyCount1 = GetNotifyCount();

   179 	

   180 	//Set the Test Notifier Response

   181 	err = SetNotifierResponse();

   182 	TESTEL(KErrNone == err, err);

   183 

   184 	//Call Connect()

   185 	err = ConnectTcpSocket(sock, iEchoServerAddr);

   186 	TESTL(KErrNone == CheckResult(err));

   187 

   188 	//Get the NotifyCount after the RSocket::...() API is called

   189 	TInt notifyCount2 = GetNotifyCount();

   190 

   191 	//Check the Prompt Occurred as expected

   192 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   193 	TEST(KErrNone == err);

   194 	

   195 	err = DestroyTcpSocket(sock);

   196 	TESTEL((KErrNone == err || KErrPermissionDenied == err), err);

   197 	CleanupStack::Pop();

   198 

   199 	CloseSocketServer(ss);

   200 	CleanupStack::Pop();

   201 

   202 	return TestStepResult();

   203 } // TE_RConnectionUPSTest1a

   204 

   205 

   206 

   207 TE_RConnectionUPSTest1b::~TE_RConnectionUPSTest1b()

   208 {

   209 }

   210 

   211 enum TVerdict TE_RConnectionUPSTest1b::doTestStepL(void)

   212 /**

   213  * Test prompting behaviour when calling:

   214  * Implicit RSocket::SendTo() on a UDP socket

   215  */

   216 {

   217 	TInt err;

   218 	

   219 	//Delete entries in the DecisionDB

   220 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   221 

   222 	RSocketServ ss;

   223 	RSocket sock;

   224 	

   225 	err = OpenSocketServer(ss);

   226 	TESTEL(KErrNone == err, err);

   227 	CleanupClosePushL(ss);

   228 

   229 	err = OpenUdpSocketL(sock, ss);

   230 	TESTEL(KErrNone == err, err);

   231 	CleanupClosePushL(sock);

   232 	

   233 	//Get the NotifyCount beforethe RSocket::...() API is called

   234 	TInt notifyCount1 = GetNotifyCount();

   235 

   236 	//Set the Test Notifier Response

   237 	err = SetNotifierResponse();

   238 	TESTEL(KErrNone == err, err);

   239 

   240 	//Call SendTo() and RecvFrom()

   241 	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

   242 	TESTL(KErrNone == CheckResult(err));

   243 	

   244 	//Get the NotifyCount after the RSocket::...() API is called

   245 	TInt notifyCount2 = GetNotifyCount();

   246 

   247 	//Check the Prompt Occurred as expected

   248 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   249 	TEST(KErrNone == err);

   250 

   251 	DestroyUdpSocket(sock);

   252 	CleanupStack::Pop();

   253 

   254 	CloseSocketServer(ss);

   255 	CleanupStack::Pop();

   256 

   257 	return TestStepResult();

   258 } // TE_RConnectionUPSTest1b

   259 

   260 

   261 

   262 TE_RConnectionUPSTest1c::~TE_RConnectionUPSTest1c()

   263 {

   264 }

   265 

   266 enum TVerdict TE_RConnectionUPSTest1c::doTestStepL(void)

   267 /**

   268  * Test prompting behaviour when calling:

   269  * Implicit Synchronous RHostResolver::GetByName()

   270  */

   271 {

   272 	TInt err;

   273 	

   274 	//Delete entries in the DecisionDB

   275 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   276 	

   277 	RSocketServ ss;

   278 	RHostResolver hr;

   279 

   280 	err = OpenSocketServer(ss);

   281 	TESTEL(KErrNone == err, err);

   282 	CleanupClosePushL(ss);

   283 

   284 	err = OpenHostResolver(hr, ss);

   285 	TESTEL(KErrNone == err, err);

   286 	CleanupClosePushL(hr);

   287 

   288 	//Get the NotifyCount before the RHostResolver::...() API is called

   289 	TInt notifyCount1 = GetNotifyCount();

   290 	

   291 	//Set the Test Notifier Response

   292 	err = SetNotifierResponse();

   293 	TESTEL(KErrNone == err, err);

   294 	

   295 	//Call GetByName()

   296 	err = MakeSynchronousNameRequest(hr, iTestName);

   297 	TESTL(KErrNone == CheckResult(err));

   298 	

   299 	//Get the NotifyCount after the RHostResolver::...() API is called

   300 	TInt notifyCount2 = GetNotifyCount();

   301 

   302 	//Check the Prompt Occurred as expected

   303 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   304 	TEST(KErrNone == err);

   305 

   306 	DestroyHostResolver(hr);

   307 	CleanupStack::Pop();

   308 

   309 	CloseSocketServer(ss);

   310 	CleanupStack::Pop();

   311 

   312 	return TestStepResult();

   313 } // TE_RConnectionUPSTest1c

   314 

   315 

   316 

   317 TE_RConnectionUPSTest1d::~TE_RConnectionUPSTest1d()

   318 {

   319 }

   320 

   321 enum TVerdict TE_RConnectionUPSTest1d::doTestStepL(void)

   322 /**

   323  * Test prompting behaviour when calling:

   324  * Implicit Synchronous RHostResolver::GetByAddress()

   325  */ 

   326 {

   327 	TInt err;

   328 

   329 	//Delete entries in the DecisionDB

   330 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   331 	

   332 	RSocketServ ss;

   333 	RHostResolver hr;

   334 

   335 	err = OpenSocketServer(ss);

   336 	TESTEL(KErrNone == err, err);

   337 	CleanupClosePushL(ss);

   338 

   339 	err = OpenHostResolver(hr, ss);

   340 	TESTEL(KErrNone == err, err);

   341 	CleanupClosePushL(hr);

   342 

   343 	//Get the NotifyCount before the RHostResolver::...() API is called

   344 	TInt notifyCount1 = GetNotifyCount();

   345 	

   346 	//Set the Test Notifier Response

   347 	err = SetNotifierResponse();

   348 	TESTEL(KErrNone == err, err);

   349 	

   350 	//Call GetByAddress()

   351 	err = MakeSynchronousAddressRequest(hr, iLookupAddress);

   352 	TESTL(KErrNone == CheckResult(err));

   353 	

   354 	//Get the NotifyCount after the RHostResolver::...() API is called

   355 	TInt notifyCount2 = GetNotifyCount();

   356 

   357 	//Check the Prompt Occurred as expected

   358 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   359 	TEST(KErrNone == err);

   360 

   361 	DestroyHostResolver(hr);

   362 	CleanupStack::Pop();

   363 

   364 	CloseSocketServer(ss);

   365 	CleanupStack::Pop();

   366 

   367 	return TestStepResult();

   368 

   369 } // TE_RConnectionUPSTest1d

   370 

   371 

   372 

   373 TE_RConnectionUPSTest2a::~TE_RConnectionUPSTest2a()

   374 {

   375 }

   376 

   377 enum TVerdict TE_RConnectionUPSTest2a::doTestStepL(void)

   378 /**

   379  * Test prompting behaviour when calling:

   380  * Implicit RSocket::Connect() followed by another Implicit

   381  * RSocket::Connect()

   382  */

   383 {

   384 	TInt err;

   385 

   386 	//Delete entries in the DecisionDB

   387 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   388 	

   389 	RSocketServ ss;

   390 	RSocket sock;	

   391 	

   392 	err = OpenSocketServer(ss);

   393 	TESTEL(KErrNone == err, err);

   394 	CleanupClosePushL(ss);

   395 

   396 	err = OpenTcpSocket(sock, ss);

   397 	TESTEL(KErrNone == err, err);

   398 	CleanupClosePushL(sock);

   399 	

   400 	//Get the NotifyCount before the RSocket::...() API is called

   401 	TInt notifyCount1 = GetNotifyCount();

   402 	

   403 	//Set the Test Notifier Response

   404 	err = SetNotifierResponse();

   405 	TESTEL(KErrNone == err, err);

   406 

   407 	//Call Connect()

   408 	err = ConnectTcpSocket(sock, iEchoServerAddr);

   409 	TESTL(KErrNone == CheckResult(err));

   410 

   411 	//Get the NotifyCount after the RSocket::...() API is called

   412 	TInt notifyCount2 = GetNotifyCount();

   413 

   414 	//Check the Prompt Occurred as expected

   415 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   416 	TEST(KErrNone == err);

   417 	

   418 	

   419 	RSocket sock2;

   420 	err = OpenTcpSocket(sock2, ss);

   421 	TESTEL(KErrNone == err, err);

   422 	CleanupClosePushL(sock2);

   423 

   424 	//Get the NotifyCount before the RSocket::...() API is called

   425 	notifyCount1 = GetNotifyCount();

   426 	

   427 	//Set the Test Notifier Response

   428 	err = SetNotifierResponse();

   429 	TESTEL(KErrNone == err, err);

   430 

   431 	//Call Connect()

   432 	err = ConnectTcpSocket(sock2, iEchoServerAddr);

   433 	TESTL(KErrNone == CheckResult(err));

   434 

   435 	//Get the NotifyCount after the RSocket::...() API is called

   436 	notifyCount2 = GetNotifyCount();

   437 

   438 	//Check the Prompt Occurred as expected

   439 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   440 	TEST(KErrNone == err);

   441 	

   442 	err = DestroyTcpSocket(sock2);

   443 	TESTEL((KErrNone == err || KErrPermissionDenied == err), err);

   444 	CleanupStack::Pop(); //sock2

   445 	

   446 	err = DestroyTcpSocket(sock);

   447 	TESTEL((KErrNone == err || KErrPermissionDenied == err), err);

   448 	CleanupStack::Pop(); //sock

   449 

   450 	CloseSocketServer(ss);

   451 	CleanupStack::Pop(); //ss

   452 

   453 	return TestStepResult();

   454 } // TE_RConnectionUPSTest2a

   455 

   456 

   457 

   458 TE_RConnectionUPSTest2b::~TE_RConnectionUPSTest2b()

   459 {

   460 }

   461 

   462 enum TVerdict TE_RConnectionUPSTest2b::doTestStepL(void)

   463 /**

   464  * Test prompting behaviour when calling:

   465  * Implicit RSocket::SendTo() followed by another Implicit

   466  * RSocket::SendTo()

   467  */

   468 {

   469 	TInt err;

   470 

   471 	//Delete entries in the DecisionDB

   472 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   473 	

   474 	RSocketServ ss;

   475 	RSocket sock;

   476 	

   477 	err = OpenSocketServer(ss);

   478 	TESTEL(KErrNone == err, err);

   479 	CleanupClosePushL(ss);

   480 

   481 	err = OpenUdpSocketL(sock, ss);

   482 	TESTEL(KErrNone == err, err);

   483 	CleanupClosePushL(sock);

   484 

   485 	//Get the NotifyCount before the RSocket::...() API is called

   486 	TInt notifyCount1 = GetNotifyCount();

   487 	

   488 	//Set the Test Notifier Response

   489 	err = SetNotifierResponse();

   490 	TESTEL(KErrNone == err, err);

   491 

   492 	//Call SendTo() and RecvFrom()

   493 	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

   494 	TESTL(KErrNone == CheckResult(err));

   495 	

   496 	//Get the NotifyCount after the RSocket::...() API is called

   497 	TInt notifyCount2 = GetNotifyCount();

   498 

   499 	//Check the Prompt Occurred as expected

   500 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   501 	TEST(KErrNone == err);

   502 	

   503 	

   504 	RSocket sock2;

   505 	err = OpenUdpSocketL(sock2, ss);

   506 	TESTEL(KErrNone == err, err);

   507 	CleanupClosePushL(sock2);

   508 

   509 	//Get the NotifyCount before the RSocket::...() API is called

   510 	notifyCount1 = GetNotifyCount();

   511 	

   512 	//Set the Test Notifier Response

   513 	err = SetNotifierResponse();

   514 	TESTEL(KErrNone == err, err);

   515 

   516 	//Call SendTo() and RecvFrom()

   517 	err = TestUdpDataPathL(sock2, iDummyNifSendAddr);

   518 	TESTL(KErrNone == CheckResult(err));

   519 	

   520 	//Get the NotifyCount after the RSocket::...() API is called

   521 	notifyCount2 = GetNotifyCount();

   522 

   523 	//Check the Prompt Occurred as expected

   524 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   525 	TEST(KErrNone == err);

   526 

   527 	DestroyUdpSocket(sock2);

   528 	CleanupStack::Pop(); //sock2

   529 

   530 	DestroyUdpSocket(sock);

   531 	CleanupStack::Pop(); //sock

   532 

   533 	CloseSocketServer(ss);

   534 	CleanupStack::Pop(); //ss

   535 

   536 	return TestStepResult();

   537 } // TE_RConnectionUPSTest2b

   538 

   539 

   540 

   541 TE_RConnectionUPSTest2c::~TE_RConnectionUPSTest2c()

   542 {

   543 }

   544 

   545 enum TVerdict TE_RConnectionUPSTest2c::doTestStepL(void)

   546 /**

   547  * Test prompting behaviour when calling:

   548  * Implicit Synchronous RHostResolver::GetByName() followed by an Implicit

   549  * Asynchronous RHostResolver::GetByName()

   550  */

   551 {

   552 	TInt err;

   553 	

   554 	//Delete entries in the DecisionDB

   555 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   556 	

   557 	RSocketServ ss;

   558 	RHostResolver hr;

   559 

   560 	err = OpenSocketServer(ss);

   561 	TESTEL(KErrNone == err, err);

   562 	CleanupClosePushL(ss);

   563 

   564 	err = OpenHostResolver(hr, ss);

   565 	TESTEL(KErrNone == err, err);

   566 	CleanupClosePushL(hr);

   567 

   568 	//Get the NotifyCount before the RHostResolver::...() API is called

   569 	TInt notifyCount1 = GetNotifyCount();

   570 	

   571 	//Set the Test Notifier Response

   572 	err = SetNotifierResponse();

   573 	TESTEL(KErrNone == err, err);

   574 	

   575 	//Call GetByName()

   576 	err = MakeSynchronousNameRequest(hr, iTestName);

   577 	TESTL(KErrNone == CheckResult(err));

   578 	

   579 	//Get the NotifyCount after the RHostResolver::...() API is called

   580 	TInt notifyCount2 = GetNotifyCount();

   581 

   582 	//Check the Prompt Occurred as expected

   583 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   584 	TEST(KErrNone == err);

   585 	

   586 

   587 	RHostResolver hr2;

   588 	err = OpenHostResolver(hr2, ss);

   589 	TESTEL(KErrNone == err, err);

   590 	CleanupClosePushL(hr2);

   591 

   592 	//Get the NotifyCount before the RHostResolver::...() API is called

   593 	notifyCount1 = GetNotifyCount();

   594 	

   595 	//Set the Test Notifier Response

   596 	err = SetNotifierResponse();

   597 	TESTEL(KErrNone == err, err);

   598 	

   599 	//Call GetByName()

   600 	err = MakeNameRequest(hr2, iTestName);

   601 	TESTL(KErrNone == CheckResult(err));

   602 	

   603 	//Get the NotifyCount after the RHostResolver::...() API is called

   604 	notifyCount2 = GetNotifyCount();

   605 

   606 	//Check the Prompt Occurred as expected

   607 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   608 	TEST(KErrNone == err);

   609 

   610 	DestroyHostResolver(hr2);

   611 	CleanupStack::Pop(); //hr2

   612 

   613 	DestroyHostResolver(hr);

   614 	CleanupStack::Pop(); //hr

   615 

   616 	CloseSocketServer(ss);

   617 	CleanupStack::Pop(); //ss

   618 

   619 	return TestStepResult();

   620 } // TE_RConnectionUPSTest2c

   621 

   622 

   623 

   624 TE_RConnectionUPSTest2d::~TE_RConnectionUPSTest2d()

   625 {

   626 }

   627 

   628 enum TVerdict TE_RConnectionUPSTest2d::doTestStepL(void)

   629 /**

   630  * Test prompting behaviour when calling:

   631  * Implicit Synchronous RHostResolver::GetByAddress() followed by an Implicit

   632  * Asynchronous RHostResolver::GetByAddress()

   633  */

   634 {

   635 	TInt err;

   636 

   637 	//Delete entries in the DecisionDB

   638 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   639 

   640 	RSocketServ ss;

   641 	RHostResolver hr;

   642 	

   643 	err = OpenSocketServer(ss);

   644 	TESTEL(KErrNone == err, err);

   645 	CleanupClosePushL(ss);

   646 

   647 	err = OpenHostResolver(hr, ss);

   648 	TESTEL(KErrNone == err, err);

   649 	CleanupClosePushL(hr);

   650 

   651 	//Get the NotifyCount before the RHostResolver::...() API is called

   652 	TInt notifyCount1 = GetNotifyCount();

   653 	

   654 	//Set the Test Notifier Response

   655 	err = SetNotifierResponse();

   656 	TESTEL(KErrNone == err, err);

   657 	

   658 	//Call GetByAddress()

   659 	err = MakeSynchronousAddressRequest(hr, iLookupAddress);

   660 	TESTL(KErrNone == CheckResult(err));

   661 	

   662 	//Get the NotifyCount after the RHostResolver::...() API is called

   663 	TInt notifyCount2 = GetNotifyCount();

   664 

   665 	//Check the Prompt Occurred as expected

   666 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   667 	TEST(KErrNone == err);

   668 

   669 

   670 	RHostResolver hr2;

   671 	err = OpenHostResolver(hr2, ss);

   672 	TESTEL(KErrNone == err, err);

   673 	CleanupClosePushL(hr2);

   674 

   675 	//Get the NotifyCount before the RHostResolver::...() API is called

   676 	notifyCount1 = GetNotifyCount();

   677 	

   678 	//Set the Test Notifier Response

   679 	err = SetNotifierResponse();

   680 	TESTEL(KErrNone == err, err);

   681 	

   682 	//Call GetByAddress()

   683 	err = MakeAddressRequest(hr2, iLookupAddress);

   684 	TESTL(KErrNone == CheckResult(err));

   685 	

   686 	//Get the NotifyCount after the RHostResolver::...() API is called

   687 	notifyCount2 = GetNotifyCount();

   688 

   689 	//Check the Prompt Occurred as expected

   690 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   691 	TEST(KErrNone == err);

   692 

   693 

   694 	DestroyHostResolver(hr2);

   695 	CleanupStack::Pop(); //hr2

   696 	

   697 	DestroyHostResolver(hr);

   698 	CleanupStack::Pop(); //hr

   699 

   700 	CloseSocketServer(ss);

   701 	CleanupStack::Pop(); //ss

   702 

   703 	return TestStepResult();

   704 

   705 } // TE_RConnectionUPSTest2d

   706 

   707 

   708 

   709 TE_RConnectionUPSTest3a::~TE_RConnectionUPSTest3a()

   710 {

   711 }

   712 

   713 enum TVerdict TE_RConnectionUPSTest3a::doTestStepL(void)

   714 /**

   715  * Test prompting behaviour when calling:

   716  * Implicit RSocket::Connect(), close RSocket, followed by

   717  * Implicit RSocket2::Connect()

   718  *

   719  * This test should behave differently in NetworkLifetime Mode

   720  * when Notifier response is Session based, since decision is no

   721  * longer valid once first RSocket is closed i.e. once all client 

   722  * associations with connections cease to exist

   723  */

   724 {

   725 	TInt err;

   726 

   727 	//Delete entries in the DecisionDB

   728 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   729 	

   730 	RSocketServ ss;

   731 	RSocket sock;

   732 

   733 	err = OpenSocketServer(ss);

   734 	TESTEL(KErrNone == err, err);

   735 	CleanupClosePushL(ss);

   736 

   737 	err = OpenTcpSocket(sock, ss);

   738 	TESTEL(KErrNone == err, err);

   739 	CleanupClosePushL(sock);

   740 

   741 	//Get the NotifyCount before the RSocket::...() API is called

   742 	TInt notifyCount1 = GetNotifyCount();

   743 	

   744 	//Set the Test Notifier Response

   745 	err = SetNotifierResponse();

   746 	TESTEL(KErrNone == err, err);

   747 

   748 	//Call Connect()

   749 	err = ConnectTcpSocket(sock, iEchoServerAddr);

   750 	TESTL(KErrNone == CheckResult(err));

   751 

   752 	//Get the NotifyCount after the RSocket::...() API is called

   753 	TInt notifyCount2 = GetNotifyCount();

   754 

   755 	//Check the Prompt Occurred as expected

   756 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   757 	TEST(KErrNone == err);

   758 	

   759 	//Close the first Socket object

   760 	err = DestroyTcpSocket(sock);

   761 	TESTEL((KErrNone == err || KErrPermissionDenied == err), err);

   762 	CleanupStack::Pop(); //sock

   763 

   764 

   765 	RSocket sock2;

   766 	err = OpenTcpSocket(sock2, ss);

   767 	TESTEL(KErrNone == err, err);

   768 	CleanupClosePushL(sock2);

   769 

   770 	//Get the NotifyCount before the RSocket::...() API is called

   771 	notifyCount1 = GetNotifyCount();

   772 	

   773 	//Set the Test Notifier Response

   774 	err = SetNotifierResponse();

   775 	TESTEL(KErrNone == err, err);

   776 

   777 	//Call Connect()

   778 	err = ConnectTcpSocket(sock2, iEchoServerAddr);

   779 	TESTL(KErrNone == CheckResult(err));

   780 

   781 	//Get the NotifyCount after the RSocket::...() API is called

   782 	notifyCount2 = GetNotifyCount();

   783 

   784 	//Check the Prompt Occurred as expected

   785 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   786 	TEST(KErrNone == err);

   787 

   788 	err = DestroyTcpSocket(sock2);

   789 	TESTEL((KErrNone == err || KErrPermissionDenied == err), err);

   790 	CleanupStack::Pop(); //sock2

   791 

   792 	CloseSocketServer(ss);

   793 	CleanupStack::Pop(); //ss

   794 

   795 	return TestStepResult();

   796 } // TE_RConnectionUPSTest3a

   797 

   798 

   799 

   800 TE_RConnectionUPSTest3b::~TE_RConnectionUPSTest3b()

   801 {

   802 }

   803 

   804 enum TVerdict TE_RConnectionUPSTest3b::doTestStepL(void)

   805 /**

   806  * Test prompting behaviour when calling:

   807  * Implicit RSocket::SendTo(), close RSocket, followed by

   808  * Implicit RSocket2::SendTo()

   809  *

   810  * This test should behave differently in NetworkLifetime Mode

   811  * when Notifier response is Session based, since decision is no

   812  * longer valid once first RSocket is closed i.e. once all client 

   813  * associations with connections cease to exist

   814  */

   815 {

   816 	TInt err;

   817 

   818 	//Delete entries in the DecisionDB

   819 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   820 	

   821 	RSocketServ ss;

   822 	RSocket sock;

   823 

   824 	err = OpenSocketServer(ss);

   825 	TESTEL(KErrNone == err, err);

   826 	CleanupClosePushL(ss);

   827 

   828 	err = OpenUdpSocketL(sock, ss);

   829 	TESTEL(KErrNone == err, err);

   830 	CleanupClosePushL(sock);

   831 

   832 	//Get the NotifyCount before the RSocket::...() API is called

   833 	TInt notifyCount1 = GetNotifyCount();

   834 

   835 	//Set the Test Notifier Response

   836 	err = SetNotifierResponse();

   837 	TESTEL(KErrNone == err, err);

   838 

   839 	//Call SendTo() and RecvFrom()

   840 	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

   841 	TESTL(KErrNone == CheckResult(err));

   842 

   843 	//Get the NotifyCount after the RSocket::...() API is called

   844 	TInt notifyCount2 = GetNotifyCount();

   845 

   846 	//Check the Prompt Occurred as expected

   847 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   848 	TEST(KErrNone == err);

   849 	

   850 	//Close the first Socket object

   851 	DestroyUdpSocket(sock);

   852 	CleanupStack::Pop(); //sock

   853 

   854 

   855 	RSocket sock2;

   856 	err = OpenUdpSocketL(sock2, ss);

   857 	TESTEL(KErrNone == err, err);

   858 	CleanupClosePushL(sock2);

   859 

   860 	//Get the NotifyCount before the RSocket::...() API is called

   861 	notifyCount1 = GetNotifyCount();

   862 	

   863 	//Set the Test Notifier Response

   864 	err = SetNotifierResponse();

   865 	TESTEL(KErrNone == err, err);

   866 

   867 	//Call SendTo() and RecvFrom()

   868 	err = TestUdpDataPathL(sock2, iDummyNifSendAddr);

   869 	TESTL(KErrNone == CheckResult(err));

   870 

   871 	//Get the NotifyCount after the RSocket::...() API is called

   872 	notifyCount2 = GetNotifyCount();

   873 

   874 	//Check the Prompt Occurred as expected

   875 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   876 	TEST(KErrNone == err);

   877 

   878 	DestroyUdpSocket(sock2);

   879 	CleanupStack::Pop(); //sock2

   880 

   881 	CloseSocketServer(ss);

   882 	CleanupStack::Pop(); //ss

   883 

   884 	return TestStepResult();

   885 } // TE_RConnectionUPSTest3b

   886 

   887 

   888 

   889 TE_RConnectionUPSTest3c::~TE_RConnectionUPSTest3c()

   890 {

   891 }

   892 

   893 enum TVerdict TE_RConnectionUPSTest3c::doTestStepL(void)

   894 /**

   895  * Test prompting behaviour when calling:

   896  * Implicit Synchronous RHostResolver::GetByName(), close RHostResolver,

   897  * followed by implicit Asynchronous RHostResolver2::GetByName()

   898  *

   899  * This test should behave differently in NetworkLifetime Mode

   900  * when Notifier response is Session based, since decision is no

   901  * longer valid once first RHostResolver is closed i.e. once all client 

   902  * associations with connections cease to exist

   903  */

   904 {

   905 	TInt err;

   906 	

   907 	//Delete entries in the DecisionDB

   908 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   909 	

   910 	RSocketServ ss;

   911 	RHostResolver hr;

   912 

   913 	err = OpenSocketServer(ss);

   914 	TESTEL(KErrNone == err, err);

   915 	CleanupClosePushL(ss);

   916 	

   917 	err = OpenHostResolver(hr, ss);

   918 	TESTEL(KErrNone == err, err);

   919 	CleanupClosePushL(hr);

   920 	

   921 	//Get the NotifyCount before the RHostResolver::...() API is called

   922 	TInt notifyCount1 = GetNotifyCount();

   923 		

   924 	//Set the Test Notifier Response

   925 	err = SetNotifierResponse();

   926 	TESTEL(KErrNone == err, err);

   927 	

   928 	//Call GetByName()

   929 	err = MakeSynchronousNameRequest(hr, iTestName);

   930 	TESTL(KErrNone == CheckResult(err));

   931 	

   932 	//Get the NotifyCount after the RHostResolver::...() API is called

   933 	TInt notifyCount2 = GetNotifyCount();

   934 

   935 	//Check the Prompt Occurred as expected

   936 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   937 	TEST(KErrNone == err);

   938 	

   939 	//Close the first HostResolver object

   940 	DestroyHostResolver(hr);

   941 	CleanupStack::Pop(); //hr

   942 	

   943 

   944 	RHostResolver hr2;	

   945 	err = OpenHostResolver(hr2, ss);

   946 	TESTEL(KErrNone == err, err);

   947 	CleanupClosePushL(hr2);

   948 	

   949 	//Get the NotifyCount before the RHostResolver::...() API is called

   950 	notifyCount1 = GetNotifyCount();

   951 	

   952 	//Set the Test Notifier Response

   953 	err = SetNotifierResponse();

   954 	TESTEL(KErrNone == err, err);

   955 	

   956 	//Call GetByName()

   957 	err = MakeNameRequest(hr2, iTestName);

   958 	TESTL(KErrNone == CheckResult(err));

   959 	

   960 	//Get the NotifyCount after the RHostResolver::...() API is called

   961 	notifyCount2 = GetNotifyCount();

   962 

   963 	//Check the Prompt Occurred as expected

   964 	err = CheckNotifyCount(notifyCount1, notifyCount2);

   965 	TEST(KErrNone == err);

   966 	

   967 	DestroyHostResolver(hr2);

   968 	CleanupStack::Pop(); //hr2

   969 	

   970 	CloseSocketServer(ss);

   971 	CleanupStack::Pop(); //ss

   972 	

   973 	return TestStepResult();

   974 } // TE_RConnectionUPSTest3c

   975 

   976 

   977 TE_RConnectionUPSTest3d::~TE_RConnectionUPSTest3d()

   978 {

   979 }

   980 

   981 enum TVerdict TE_RConnectionUPSTest3d::doTestStepL(void)

   982 /**

   983  * Test prompting behaviour when calling:

   984  * Implicit Synchronous RHostResolver::GetByAddress(), close RHostResolver,

   985  * followed by implicit Asynchronous RHostResolver2::GetByAddress()

   986  *

   987  * This test should behave differently in NetworkLifetime Mode

   988  * when Notifier response is Session based, since decision is no

   989  * longer valid once first RHostResolver is closed i.e. once all client 

   990  * associations with connections cease to exist

   991  */

   992 {

   993 	TInt err;

   994 	

   995 	//Delete entries in the DecisionDB

   996 	TESTL(KErrNone == CheckAndDeleteUpsDB());

   997 	

   998 	RSocketServ ss;

   999 	RHostResolver hr;

  1000 

  1001 	err = OpenSocketServer(ss);

  1002 	TESTEL(KErrNone == err, err);

  1003 	CleanupClosePushL(ss);

  1004 	

  1005 	err = OpenHostResolver(hr, ss);

  1006 	TESTEL(KErrNone == err, err);

  1007 	CleanupClosePushL(hr);

  1008 		

  1009 	//Get the NotifyCount before the RHostResolver::...() API is called

  1010 	TInt notifyCount1 = GetNotifyCount();

  1011 	

  1012 	//Set the Test Notifier Response

  1013 	err = SetNotifierResponse();

  1014 	TESTEL(KErrNone == err, err);

  1015 	

  1016 	//Call GetByAddress()

  1017 	err = MakeSynchronousAddressRequest(hr, iLookupAddress);

  1018 	TESTL(KErrNone == CheckResult(err));

  1019 	

  1020 	//Get the NotifyCount after the RHostResolver::...() API is called

  1021 	TInt notifyCount2 = GetNotifyCount();

  1022 

  1023 	//Check the Prompt Occurred as expected

  1024 	err = CheckNotifyCount(notifyCount1, notifyCount2);

  1025 	TEST(KErrNone == err);

  1026 

  1027 	DestroyHostResolver(hr);

  1028 	CleanupStack::Pop(); //hr

  1029 		

  1030 	

  1031 	RHostResolver hr2;	

  1032 	err = OpenHostResolver(hr2, ss);

  1033 	TESTEL(KErrNone == err, err);

  1034 	CleanupClosePushL(hr2);

  1035 	

  1036 	//Get the NotifyCount before the RHostResolver::...() API is called

  1037 	notifyCount1 = GetNotifyCount();

  1038 	

  1039 	//Set the Test Notifier Response

  1040 	err = SetNotifierResponse();

  1041 	TESTEL(KErrNone == err, err);

  1042 	

  1043 	//Call GetByAddress()

  1044 	err = MakeAddressRequest(hr2, iLookupAddress);

  1045 	TESTL(KErrNone == CheckResult(err));

  1046 	

  1047 	//Get the NotifyCount after the RHostResolver::...() API is called

  1048 	notifyCount2 = GetNotifyCount();

  1049 

  1050 	//Check the Prompt Occurred as expected

  1051 	err = CheckNotifyCount(notifyCount1, notifyCount2);

  1052 	TEST(KErrNone == err);

  1053 	

  1054 	DestroyHostResolver(hr2);

  1055 	CleanupStack::Pop(); //hr2

  1056 	

  1057 	CloseSocketServer(ss);

  1058 	CleanupStack::Pop(); //ss

  1059 	

  1060 	return TestStepResult();

  1061 } // TE_RConnectionUPSTest3d

  1062 

  1063 

  1064 TE_RConnectionUPSTest4a::~TE_RConnectionUPSTest4a()

  1065 {

  1066 }

  1067 

  1068 enum TVerdict TE_RConnectionUPSTest4a::doTestStepL(void)

  1069 /**

  1070  * Test prompting behaviour when calling:

  1071  * Implicit RSocket::Connect(), followed by an Implicit 

  1072  * RHostResolver::GetByName()

  1073  */

  1074 {

  1075 	TInt err;

  1076 

  1077 	//Delete entries in the DecisionDB

  1078 	TESTL(KErrNone == CheckAndDeleteUpsDB());

  1079 	

  1080 	RSocketServ ss;

  1081 	RSocket sock;	

  1082 	

  1083 	err = OpenSocketServer(ss);

  1084 	TESTEL(KErrNone == err, err);

  1085 	CleanupClosePushL(ss);

  1086 

  1087 	err = OpenTcpSocket(sock, ss);

  1088 	TESTEL(KErrNone == err, err);

  1089 	CleanupClosePushL(sock);

  1090 	

  1091 	//Get the NotifyCount before the RSocket::...() API is called

  1092 	TInt notifyCount1 = GetNotifyCount();

  1093 	

  1094 	//Set the Test Notifier Response

  1095 	err = SetNotifierResponse();

  1096 	TESTEL(KErrNone == err, err);

  1097 

  1098 	//Call Connect()

  1099 	err = ConnectTcpSocket(sock, iEchoServerAddr);

  1100 	TESTL(KErrNone == CheckResult(err));

  1101 

  1102 	//Get the NotifyCount after the RSocket::...() API is called

  1103 	TInt notifyCount2 = GetNotifyCount();

  1104 

  1105 	//Check the Prompt Occurred as expected

  1106 	err = CheckNotifyCount(notifyCount1, notifyCount2);

  1107 	TEST(KErrNone == err);

  1108 

  1109 	

  1110 	RHostResolver hr;	

  1111 	err = OpenHostResolver(hr, ss);

  1112 	TESTEL(KErrNone == err, err);

  1113 	CleanupClosePushL(hr);

  1114 	

  1115 	//Get the NotifyCount before the RHostResolver::...() API is called

  1116 	notifyCount1 = GetNotifyCount();

  1117 	

  1118 	//Set the Test Notifier Response

  1119 	err = SetNotifierResponse();

  1120 	TESTEL(KErrNone == err, err);

  1121 	

  1122 	//Call GetByName()

  1123 	err = MakeSynchronousNameRequest(hr, iTestName);

  1124 	TESTL(KErrNone == CheckResult(err));

  1125 	

  1126 	//Get the NotifyCount after the RHostResolver::...() API is called

  1127 	notifyCount2 = GetNotifyCount();

  1128 

  1129 	//Check the Prompt Occurred as expected

  1130 	err = CheckNotifyCount(notifyCount1, notifyCount2);

  1131 	TEST(KErrNone == err);

  1132 	

  1133 	DestroyHostResolver(hr);

  1134 	CleanupStack::Pop(); //hr

  1135