1 // Copyright (c) 2006-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 //

    15 

    16 // EPOC includes

    17 #include <e32base.h>

    18 #include "TE_SocketServerTestSections.h"

    19 #include<c32root.h>

    20 #include <es_panic.h>

    21 #include <elements/sd_std.h>

    22 #include <comms-infras/sockmes.h>

    23 

    24 // Test step 1

    25 const TDesC& CSocketServerTest1::GetTestName()

    26 	{

    27 	_LIT(cRet,"Test1");

    28 	return cRet;

    29 	}

    30 

    31 CSocketServerTest1::CSocketServerTest1()

    32 	{

    33 	}

    34 

    35 CSocketServerTest1::~CSocketServerTest1()

    36 	{

    37 	}

    38 

    39 enum TVerdict CSocketServerTest1::InternalDoTestStepL( void )

    40 	{

    41 	TVerdict verdict = EPass;

    42 	TInt ret;

    43 

    44 	Logger().WriteFormat(_L("TE_SocketServer Test1"));

    45 	Logger().WriteFormat(_L("Test Purpose: Attempts to connect directly to optimal SocketServer without first connecting to SocketServer"));

    46 	

    47 	// connect to esock

    48 	Logger().WriteFormat(_L("Attempting direct optimal connection to socket server - should fail and panic"));

    49     RSocketServ ss1;

    50 	ret = IllegalOptimalConnect(ss1);

    51 	

    52 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

    53 	TESTL(ret == KErrPermissionDenied);

    54 	SetTestStepResult(verdict);

    55 	return verdict;

    56 	}

    57 

    58 const TDesC& CSocketServerTest2::GetTestName()

    59 	{

    60 	_LIT(cRet,"Test2");

    61 	return cRet;

    62 	}

    63 

    64 // Test step 2

    65 CSocketServerTest2::CSocketServerTest2()

    66     {

    67     }

    68 

    69 CSocketServerTest2::~CSocketServerTest2()

    70     {

    71     }

    72 

    73 enum TVerdict CSocketServerTest2::InternalDoTestStepL( void )

    74 	{

    75 	TVerdict verdict = EPass;

    76 	TInt ret;

    77 	

    78 	Logger().WriteFormat(_L("TE_SocketServer Test2"));

    79 	Logger().WriteFormat(_L("Test Purpose: Request optimal SocketServer but connects directly to it twice"));

    80 	

    81 	// connect to esock

    82 	Logger().WriteFormat(_L("Attempting optimal connection to socket server"));

    83     RSocketServ ss1;

    84 	ret = OptimalConnect(ss1);

    85 	Logger().WriteFormat(_L("OptimalConnect returned %S"),&EpocErrorToText(ret));

    86 	TESTL(ret == KErrNone);

    87 	Logger().WriteFormat(_L("Attempting an illegal direct connection to socket server player"));

    88 	ret = IllegalOptimalConnect(ss1);

    89 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

    90 	TESTL(ret == KErrPermissionDenied);

    91 	SetTestStepResult(verdict);

    92 	return verdict;

    93 	}

    94 

    95 

    96 // Test step 3

    97 const TDesC& CSocketServerTest3::GetTestName()

    98 	{

    99 	_LIT(cRet,"Test3");

   100 	return cRet;

   101 	}

   102 

   103 CSocketServerTest3::CSocketServerTest3()

   104 	{

   105 	}

   106 

   107 CSocketServerTest3::~CSocketServerTest3()

   108 	{

   109 	}

   110 

   111 enum TVerdict CSocketServerTest3::InternalDoTestStepL( void )

   112 	{

   113 	TVerdict verdict = EPass;

   114 	

   115 	Logger().WriteFormat(_L("TE_SocketServer Test3"));

   116 	Logger().WriteFormat(_L("Test Purpose: Separate player belonging to optimal SocketServer dies"));

   117 	

   118 	// connect to esock

   119 	Logger().WriteFormat(_L("Attempting connection to socket server"));

   120     RSocketServ ss1;

   121 	TInt ret;

   122 	ret = ss1.Connect();

   123 	CleanupClosePushL(ss1);

   124 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   125 	TESTL(ret == KErrNone);

   126 	

   127 	RSocket sock1;

   128 	Logger().WriteFormat(_L("Attempting open a socket to protocol 'Dummy Protocol 1'"));

   129 	ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

   130 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   131 	TESTL(ret == KErrNone);

   132 	

   133 	Logger().WriteFormat(_L("Attempting to Panic the protocol module"));

   134 	ret = PanicProtocolModule(sock1);

   135 	Logger().WriteFormat(_L("Ioctl returned %S"),&EpocErrorToText(ret));

   136 	TESTL(ret == KErrServerTerminated || ret == KErrAbort);

   137 	

   138 	sock1.Close();

   139 	

   140 	RSocketServ ss2;

   141 	Logger().WriteFormat(_L("Attempting do normal socket server connection"));

   142 	ret = ss2.Connect();

   143 	CleanupClosePushL(ss2);

   144 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   145 	TESTL(ret == KErrNone);

   146 	

   147 	RSocketServ ss3;

   148 	Logger().WriteFormat(_L("Attempting do normal optimal socket server connection"));

   149 	ret = OptimalConnect(ss3);

   150 	CleanupClosePushL(ss3);

   151 	Logger().WriteFormat(_L("Optimal Connect returned %S"),&EpocErrorToText(ret));

   152 	TESTL(ret == KErrNone);

   153 	

   154 	RSocket sock2;

   155 	Logger().WriteFormat(_L("Attempting to connect to 'Dummy Protocol 1'"));

   156 	ret = sock2.Open(ss3,_L("Dummy Protocol 1"));

   157 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   158 	TESTL(ret != KErrNone);

   159 	

   160 	CleanupStack::PopAndDestroy();

   161 	CleanupStack::PopAndDestroy();

   162 	CleanupStack::PopAndDestroy();

   163 	

   164 	SetTestStepResult(verdict);

   165 	return verdict;

   166 	}

   167 

   168 // Test step 5

   169 const TDesC& CSocketServerTest5::GetTestName()

   170 	{

   171 	_LIT(cRet,"Test5");

   172 	return cRet;

   173 	}

   174 

   175 CSocketServerTest5::CSocketServerTest5()

   176 	{

   177 	}

   178 

   179 CSocketServerTest5::~CSocketServerTest5()

   180 	{

   181 	}

   182 

   183 enum TVerdict CSocketServerTest5::InternalDoTestStepL( void )

   184 	{

   185 	TVerdict verdict = EPass;

   186 	

   187 	Logger().WriteFormat(_L("TE_SocketServer Test5"));

   188 	Logger().WriteFormat(_L("Test Purpose: Separate player belonging to optimal SocketServer dies, without completing all messages"));

   189 	

   190 	// connect to esock

   191 	Logger().WriteFormat(_L("Attempting connection to socket server"));

   192     RSocketServ ss1;

   193 	TInt ret;

   194 	ret = ss1.Connect();

   195 	CleanupClosePushL(ss1);

   196 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   197 	TESTL(ret == KErrNone);

   198 	

   199 	Logger().WriteFormat(_L("Attempting optimal connection to socket server"));

   200     RSocketServ ss2;

   201 	ret = OptimalConnect(ss2);

   202 	CleanupClosePushL(ss2);

   203 	Logger().WriteFormat(_L("Optimal Connect returned %S"),&EpocErrorToText(ret));

   204 	TESTL(ret == KErrNone);

   205 	

   206 	RSocket sock1;

   207 	Logger().WriteFormat(_L("Attempting open a socket to protocol 'Dummy Protocol 1'"));

   208 	ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

   209 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   210 	TESTL(ret == KErrNone);

   211 	

   212 	Logger().WriteFormat(_L("Attempting to Hang the protocol module"));

   213 	TRequestStatus stat1;

   214 	NonCompletingIoclt(sock1,stat1);

   215 	

   216 	RSocket sock2;

   217 	Logger().WriteFormat(_L("Attempting to open a socket to protocol 'Dummy Protocol 1'"));

   218 	ret = sock2.Open(ss2,_L("Dummy Protocol 1"));

   219 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   220 	TESTL(ret == KErrNone);

   221 	

   222 	RProperty deathCountProp;

   223 	TRequestStatus deathCountStat;

   224 	

   225 	ret = deathCountProp.Attach(KUidSystemCategory, KUidC32RootModuleDeathKey.iUid);

   226 	deathCountProp.Subscribe(deathCountStat);

   227 	

   228 	Logger().WriteFormat(_L("Attempting to Panic the protocol module"));

   229 	ret = PanicProtocolModule(sock2);

   230 	Logger().WriteFormat(_L("Ioctl returned %S"),&EpocErrorToText(ret));

   231 	TESTL(ret == KErrServerTerminated || ret == KErrAbort);

   232 	

   233 	Logger().WriteFormat(_L("First Ioctl returned %S"),&EpocErrorToText(ret));

   234 	

   235 	User::WaitForRequest(stat1);

   236 	TESTL(stat1 == KErrServerTerminated || stat1 == KErrAbort);

   237 	

   238 	RSocketServ ss3;

   239 	Logger().WriteFormat(_L("Attempting connection to socket server"));

   240 	ret = ss3.Connect();

   241 	CleanupClosePushL(ss3);

   242 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   243 	

   244 	User::WaitForRequest(deathCountStat); //Ensure that all the cleanup has happenned	

   245 	

   246 	Logger().WriteFormat(_L("Checking for  module 'ESock_PDummy1'"));

   247 	CheckForModuleL(_L8("ESock_PDummy1"));

   248 	Logger().WriteFormat(_L("Checking for  module 'ESock_Codealer1'"));

   249 	CheckForModuleL(_L8("ESock_Codealer1"));

   250 	

   251 	

   252 	CleanupStack::PopAndDestroy(&ss3);

   253 	CleanupStack::PopAndDestroy(&ss2);

   254 	CleanupStack::PopAndDestroy(&ss1);

   255 	

   256 	SetTestStepResult(verdict);

   257 	return verdict;

   258 	}

   259 

   260 // Test step 7

   261 const TDesC& CSocketServerTest7::GetTestName()

   262 	{

   263 	_LIT(cRet,"Test7");

   264 	return cRet;

   265 	}

   266 

   267 CSocketServerTest7::CSocketServerTest7()

   268 	{

   269 	}

   270 

   271 CSocketServerTest7::~CSocketServerTest7()

   272 	{

   273 	}

   274 

   275 enum TVerdict CSocketServerTest7::InternalDoTestStepL( void )

   276 	{

   277 	TVerdict verdict = EPass;

   278 	

   279 	Logger().WriteFormat(_L("TE_SocketServer Test7"));

   280 	Logger().WriteFormat(_L("Test Purpose: Optimal SocketServer with separate player dies without the player having completed all messages"));

   281 	

   282 	// connect to esock

   283 	Logger().WriteFormat(_L("Attempting optimal connection to socket server"));

   284     RSocketServ ss1;

   285 	TInt ret;

   286 	ret = OptimalConnect(ss1);

   287 	CleanupClosePushL(ss1);

   288 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   289 	TESTL(ret == KErrNone);

   290 	

   291 	Logger().WriteFormat(_L("Attemting to open connection to 'Dummy Protocol 1'"));

   292 	RSocket sock1;

   293 	ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

   294 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   295 	TESTL(ret == KErrNone);

   296 	

   297 	Logger().WriteFormat(_L("Attemting to panic the dealer module"));

   298 	ret = PanicDealer(ss1);

   299 	sock1.Close();

   300 	if (ret == KErrNotSupported)

   301 		{

   302 		Logger().WriteFormat(_L("Test Only works for debug versions of epoc"));

   303 		verdict = EInconclusive;

   304 		}

   305 	else

   306 		{

   307 		Logger().WriteFormat(_L("Returned %S"),&EpocErrorToText(ret));

   308 		TESTL(ret == KErrServerTerminated || ret == KErrAbort);

   309 		

   310 		Logger().WriteFormat(_L("Attempting connection to socket server"));

   311 		RSocketServ ss2;

   312 		ret = ss2.Connect();

   313 		CleanupClosePushL(ss2);

   314 		Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   315 		TESTL(ret == KErrNone);

   316 		

   317 		Logger().WriteFormat(_L("Checking for  module 'ESock_Codealer2'"));

   318 		CheckForModuleL(_L8("ESock_Codealer2"));

   319 		Logger().WriteFormat(_L("Checking for  module 'ESock_Dealer2'"));

   320 		CheckForModuleL(_L8("ESock_Dealer2"));

   321 		

   322 		Logger().WriteFormat(_L("Attemting to open connection to 'Dummy Protocol 1'"));

   323 		

   324 		ret = sock1.Open(ss2,_L("Dummy Protocol 1"));

   325 		Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   326 		sock1.Close();

   327 		TESTL(ret == KErrNone);

   328 		

   329 		ret = sock1.Open(ss2,_L("Dummy Protocol 2"));

   330 		Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   331 		sock1.Close();

   332 		TESTL(ret == KErrNotFound);

   333 		CleanupStack::PopAndDestroy(&ss2);

   334 		}

   335 	CleanupStack::PopAndDestroy(&ss1);

   336 	

   337 	SetTestStepResult(verdict);

   338 	return verdict;

   339 	}

   340 

   341 // Test step 9

   342 const TDesC& CSocketServerTest9::GetTestName()

   343 	{

   344 	_LIT(cRet,"Test9");

   345 	return cRet;

   346 	}

   347 CSocketServerTest9::CSocketServerTest9()

   348 	{

   349 	}

   350 

   351 CSocketServerTest9::~CSocketServerTest9()

   352 	{

   353 	}

   354 

   355 enum TVerdict CSocketServerTest9::InternalDoTestStepL( void )

   356 	{

   357 	TVerdict verdict = EPass;

   358 	int ret;

   359 	

   360 	Logger().WriteFormat(_L("TE_SocketServer Test9"));

   361 	Logger().WriteFormat(_L("Test Purpose: Optimal SocketServer with separate player dies without the player having completed all messages"));

   362 	

   363 	// connect to esock

   364 	Logger().WriteFormat(_L("Attempting to connect to socket server"));

   365     RSocketServ ss1;

   366 	ret =ss1.Connect();

   367 	CleanupClosePushL(ss1);

   368 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   369 	TESTL(ret == KErrNone);

   370 	

   371 	Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1'"));

   372 	RSocket sock1;

   373     ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

   374 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   375 	TESTL(ret == KErrNone);

   376 	

   377 	Logger().WriteFormat(_L("Attempting optimal connect to socket server"));

   378     RSocketServ ss2;

   379 	ret = OptimalConnect(ss2);

   380 	CleanupClosePushL(ss2);

   381 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   382 	TESTL(ret == KErrNone);

   383 	

   384 	Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 2'"));

   385 	RSocket sock2;

   386     ret = sock2.Open(ss2,_L("Dummy Protocol 2"));

   387 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   388 	TESTL(ret == KErrNone);

   389 	

   390 	Logger().WriteFormat(_L("Attempting to hang protocol module 2 on socket 2"));

   391 	TRequestStatus stat2;

   392 	NonCompletingIoclt(sock2,stat2);

   393 	

   394 	RProperty deathCountProp;

   395 	TRequestStatus deathCountStat;

   396 	

   397 	ret = deathCountProp.Attach(KUidSystemCategory, KUidC32RootModuleDeathKey.iUid);

   398 

   399 	deathCountProp.Subscribe(deathCountStat);

   400 	CleanupClosePushL(deathCountProp);

   401 	Logger().WriteFormat(_L("Attempting to panic dealer on socket 3"));

   402 	ret = PanicDealer(ss2);

   403 	if (ret == KErrNotSupported)

   404 		{

   405 		Logger().WriteFormat(_L("Test Only works for debug versions of epoc"));

   406 		deathCountProp.Cancel();

   407 		User::WaitForRequest(deathCountStat); //Ensure that all the cleanup has happenned	

   408 		verdict = EInconclusive;

   409 		}

   410 	else

   411 		{

   412 		Logger().WriteFormat(_L("Ioctl returned %S on socket 3"),&EpocErrorToText(ret));

   413 		TESTL(ret == KErrServerTerminated || ret == KErrAbort);

   414 		User::WaitForRequest(deathCountStat); //Ensure that all the cleanup has happenned	

   415 		User::WaitForRequest(stat2);

   416 		ret = stat2.Int();

   417 		Logger().WriteFormat(_L("Ioctl returned %S on socket 2"),&EpocErrorToText(ret));

   418 		TESTL(ret == KErrServerTerminated || ret == KErrAbort);

   419 			

   420 		Logger().WriteFormat(_L("Checking for  module 'ESock_Codealer2' and 'ESock_Dealer2'"));

   421 		CheckForModuleL(_L8("ESock_Codealer2"));

   422 		CheckForModuleL(_L8("ESock_Dealer2"));

   423 			

   424 		Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1' on optimal socket server"));

   425 		RSocket sock2_2;

   426 	    ret = sock2_2.Open(ss2,_L("Dummy Protocol 1"));

   427 		Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   428 		TESTL(ret != KErrNone);

   429 			

   430 		Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1' on main socket server"));

   431 		RSocket sock1_2;

   432 	    ret = sock1_2.Open(ss1,_L("Dummy Protocol 1"));

   433 		Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   434 		TESTL(ret == KErrNone);

   435 		}

   436 		

   437 	CleanupStack::PopAndDestroy(&deathCountProp);

   438 	CleanupStack::PopAndDestroy(&ss2);

   439 	CleanupStack::PopAndDestroy(&ss1);

   440 	

   441 	SetTestStepResult(verdict);

   442 	return verdict;

   443 	}

   444 

   445 // Test step 16

   446 const TDesC& CSocketServerTest16::GetTestName()

   447 	{

   448 	_LIT(cRet,"Test16");

   449 	return cRet;

   450 	}

   451 CSocketServerTest16::CSocketServerTest16()

   452 	{

   453 	}

   454 

   455 CSocketServerTest16::~CSocketServerTest16()

   456 	{

   457 	}

   458 

   459 enum TVerdict CSocketServerTest16::InternalDoTestStepL( void )

   460 	{

   461 	TVerdict verdict = EPass;

   462 	TInt ret;

   463 	

   464 	Logger().WriteFormat(_L("TE_SocketServer Test16"));

   465 	Logger().WriteFormat(_L("Test Purpose: A large number of IOCTLs cause the separate player channel to be full as player is temporarily unresponsive"));

   466 	

   467 	Logger().WriteFormat(_L("Attempting to connect session 1"));

   468     RSocketServ ss1;

   469 	ret = ss1.Connect();

   470 	CleanupClosePushL(ss1);

   471 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   472 	TESTL(ret == KErrNone);

   473 	

   474 	Logger().WriteFormat(_L("Making Multiple opens"));

   475 	RSocket sock[KLargeNumSockets];

   476 	OpenMultipleSocketsL(ss1,sock,sizeof(sock)/sizeof(RSocket));

   477 	

   478 	int i;

   479 	Logger().WriteFormat(_L("Making Slow Ioctl calls"));

   480 	TRequestStatus stat[KLargeNumSockets];

   481 	for (i = 0;i < KLargeNumSockets; i++)

   482 		{

   483 		SlowIoctlReturn(sock[i],stat[i],FALSE);

   484 		Logger().WriteFormat(_L("Ioclt call %d returned %S"),i,&EpocErrorToText(ret));

   485 		TESTL(ret == KErrNone || ret == KErrServerBusy );

   486 		}

   487 	

   488 	//Now close	

   489 	for (i = 0;i < KLargeNumSockets; i++)

   490 		{

   491 		sock[i].Close();

   492 		User::WaitForRequest(stat[i]);

   493 		ret = stat[i].Int();

   494 		Logger().WriteFormat(_L("Ioclt TRequestStatus %d returned %S"),i,&EpocErrorToText(ret));

   495 		TESTL(ret == KErrNone || ret == KErrServerBusy );

   496 		}

   497 	

   498     CleanupStack::PopAndDestroy(&ss1);

   499     

   500 	SetTestStepResult(verdict);

   501 	return verdict;

   502 	}

   503 

   504 

   505 // Test step Test

   506 const TDesC& CSocketServerTest17::GetTestName()

   507 	{

   508 	_LIT(cRet,"Test17");

   509 	return cRet;

   510 	}

   511 CSocketServerTest17::CSocketServerTest17()

   512 	{

   513 	}

   514 

   515 CSocketServerTest17::~CSocketServerTest17()

   516 	{

   517 	}

   518 

   519 enum TVerdict CSocketServerTest17::InternalDoTestStepL( void )

   520 	{

   521 	TVerdict verdict = EPass;

   522 	int ret;

   523 	

   524 	// connect to esock

   525 	Logger().WriteFormat(_L("Attempting to connect to socket server"));

   526     RSocketServ ss1;

   527 	ret =ss1.Connect();

   528 	CleanupClosePushL(ss1);

   529 	Logger().WriteFormat(_L("Connect returned %S"),&EpocErrorToText(ret));

   530 	TESTL(ret == KErrNone);

   531 	

   532 	Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1'"));

   533 	RSocket sock1;

   534     ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

   535 	Logger().WriteFormat(_L("Open returned %S"),&EpocErrorToText(ret));

   536 	TESTL(ret == KErrNone);

   537 	

   538 	Logger().WriteFormat(_L("Attempting to hang protocol module 2 on socket 2"));

   539 	TRequestStatus stat1;

   540 	NonCompletingIoclt(sock1,stat1);

   541 	

   542 	CleanupStack::PopAndDestroy(&ss1);

   543 

   544 

   545 //Ensure that the Ioclt returns;	

   546 	RTimer timer;

   547 	TRequestStatus stat2;

   548 	timer.CreateLocal();

   549 	

   550 	timer.After(stat2,2000000);

   551 	

   552 	User::WaitForRequest(stat1,stat2);

   553 	

   554 	if (stat1.Int() == KRequestPending)

   555 		{

   556 		verdict = EFail;

   557 		}

   558 	if (stat2.Int() == KRequestPending)

   559 		{

   560 		timer.Cancel();

   561 		User::WaitForRequest(stat2);

   562 		}

   563 	

   564 	timer.Close();

   565 	

   566 	//must perform this here because otherwise we get stray events - bad

   567 	

   568 	SetTestStepResult(verdict);

   569 	return verdict;

   570 	}

   571 

   572 const TDesC& CSocketServerTest18::GetTestName()

   573 	{

   574 	_LIT(cRet,"Test18");

   575 	return cRet;

   576 	}

   577 CSocketServerTest18::CSocketServerTest18()

   578 	{

   579 	}

   580 

   581 CSocketServerTest18::~CSocketServerTest18()

   582 	{

   583 	}

   584 

   585 enum TVerdict CSocketServerTest18::InternalDoTestStepL( void )

   586 	{

   587 	SetTestStepResult(EFail);

   588 	TInt ret;

   589 	ret = OpenSocketProtocolStarted();

   590 	if( ret == KErrNone )

   591 		{

   592 		SetTestStepResult(EPass);

   593 		}

   594 	return TestStepResult();

   595 	};

   596 

   597 // Test step Test

   598 const TDesC& CSocketServerTest20::GetTestName()

   599 	{

   600 	_LIT(cRet,"Test20");

   601 	return cRet;

   602 	}

   603 CSocketServerTest20::CSocketServerTest20()

   604 	{

   605 	}

   606 

   607 CSocketServerTest20::~CSocketServerTest20()

   608 	{

   609 	}

   610 

   611 enum TVerdict CSocketServerTest20::InternalDoTestStepL( void )

   612 // Checking DbG functions. Make sure total space is greater than Free Space

   613 	{

   614 	

   615 	TVerdict verdict = EFail;

   616 	TInt err;

   617 	RSocketServ ss;

   618 	err = ss.Connect();

   619 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   620 	if (err != KErrNone)

   621 		{

   622 		return EFail;

   623 		}

   624 	

   625 	TInt totalSpace = ss.__DbgMbufTotalSpace();

   626 	Logger().WriteFormat(_L("Socket Server __DbgMbufTotalSpace returned %S"),&EpocErrorToText(totalSpace));

   627 	TInt freeSpace = ss.__DbgMbufFreeSpace();

   628 	Logger().WriteFormat(_L("Socket Server __DbgMbufFreeSpace returned %S"),&EpocErrorToText(freeSpace));

   629 #ifdef _DEBUG_SOCKET_FUNCTIONS	

   630 	Logger().WriteFormat(_L("_DEBUG_SOCKET_FUNCTIONS has been defined"));

   631 	if(freeSpace <= totalSpace)

   632 		{

   633 		verdict = EPass;

   634 		}

   635 #else

   636 	Logger().WriteFormat(_L("_DEBUG_SOCKET_FUNCTIONS has not been defined"));

   637 	if(totalSpace == KErrNone && freeSpace == KErrNone)

   638 		{

   639 		verdict = EPass;

   640 		}	

   641 #endif

   642 	ss.Close();

   643 	SetTestStepResult(verdict);

   644 	return verdict;

   645 	}

   646 

   647 // Test step Test

   648 const TDesC& CSocketServerTest21::GetTestName()

   649 	{

   650 	_LIT(cRet,"Test21");

   651 	return cRet;

   652 	}

   653 	

   654 CSocketServerTest21::CSocketServerTest21()

   655 	{

   656 	}

   657 

   658 CSocketServerTest21::~CSocketServerTest21()

   659 	{

   660 	}

   661 

   662 enum TVerdict CSocketServerTest21::InternalDoTestStepL( void )

   663 	//Verify that dbg functions without DEBUG_SOCKET_FUNCTIONS don't cause panic

   664 	{

   665 #ifndef _DEBUG_SOCKET_FUNCTIONS

   666 	Logger().WriteFormat(_L("_DEBUG_SOCKET_FUNCTIONS has not been defined"));

   667 	Logger().WriteFormat(_L("Verifying _Dbg functions do not crash OS"));

   668 	TVerdict verdict = EFail;

   669 	TInt err;

   670 	RSocketServ ss;

   671 	err = ss.Connect();

   672 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   673 	if (err != KErrNone)

   674 		{

   675 		return EFail;

   676 		}

   677 	// fail next mbuf allocation

   678 	err = ss.__DbgFailNext(1);

   679 	Logger().WriteFormat(_L("Socket Server __DbgFailNext returned %S"),&EpocErrorToText(err));

   680 	// Set a heap mark in the socket server of count 0

   681 	TInt err2 = ss.__DbgCheckHeap(0);

   682 	Logger().WriteFormat(_L("Socket Server __DbgCheckHeap returned %S"),&EpocErrorToText(err2));

   683 	if(err == KErrNone && err2 == KErrNone)

   684 		{

   685 		verdict = EPass;

   686 		}

   687 	ss.Close();

   688 	SetTestStepResult(verdict);

   689 	return verdict;

   690 #else

   691 	return EPass;

   692 #endif

   693 	}

   694 

   695 

   696 // Test step Test

   697 const TDesC& CSocketServerTest22::GetTestName()

   698 	{

   699 	_LIT(cRet,"Test22");

   700 	return cRet;

   701 	}

   702 CSocketServerTest22::CSocketServerTest22()

   703 	{

   704 	}

   705 

   706 CSocketServerTest22::~CSocketServerTest22()

   707 	{

   708 	}

   709 

   710 enum TVerdict CSocketServerTest22::InternalDoTestStepL( void )

   711 /* Verify that dbg functions without DEBUG_SOCKET_FUNCTIONS don't cause panic

   712  */

   713 	{

   714 #ifndef _DEBUG_SOCKET_FUNCTIONS

   715 	Logger().WriteFormat(_L("_DEBUG_SOCKET_FUNCTIONS has not been defined"));

   716 	Logger().WriteFormat(_L("Verifying _Dbg functions do not crash OS"));

   717 	TVerdict verdict = EFail;

   718 	TInt err;

   719 	RSocketServ ss;

   720 	err = ss.Connect();

   721 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   722 	if (err != KErrNone)

   723 		{

   724 		return EFail;

   725 		}

   726 	// Set a heap mark in the socket server 

   727 	err = ss.__DbgMarkHeap();

   728 	Logger().WriteFormat(_L("Socket Server __DbgMarkHeap returned %S"),&EpocErrorToText(err));

   729 	// End the heap mark in the socket server 

   730 	TInt err2 = ss.__DbgMarkEnd(0);

   731 	Logger().WriteFormat(_L("Socket Server __DbgMarkEnd returned %S"),&EpocErrorToText(err2));

   732 	if(err == KErrNone && err2 == KErrNone)

   733 		{

   734 		verdict = EPass;

   735 		}

   736 	ss.Close();

   737 	SetTestStepResult(verdict);

   738 	return verdict;

   739 #else

   740 	return EPass;

   741 #endif

   742 	}

   743 

   744 

   745 // Test step Test

   746 const TDesC& CSocketServerTest23::GetTestName()

   747 	{

   748 	_LIT(cRet,"Test23");

   749 	return cRet;

   750 	}

   751 CSocketServerTest23::CSocketServerTest23()

   752 	{

   753 	}

   754 

   755 CSocketServerTest23::~CSocketServerTest23()

   756 	{

   757 	}

   758 

   759 enum TVerdict CSocketServerTest23::InternalDoTestStepL( void )

   760 /* Simple test to verify __HeapChecking Functionality

   761  */ 

   762 	{

   763 #ifndef _DEBUG_SOCKET_FUNCTIONS

   764 	Logger().WriteFormat(_L("_DEBUG_SOCKET_FUNCTIONS has not been defined"));

   765 	Logger().WriteFormat(_L("Verifying _Dbg functions do not crash OS"));

   766 	TVerdict verdict = EFail;

   767 	TInt err;

   768 	RSocketServ ss;

   769 	err = ss.Connect();

   770 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   771 	if (err != KErrNone)

   772 		{

   773 		return EFail;

   774 		}

   775 	// Get the total space and free space in socket server, both should return KErrNone

   776 	err = ss.__DbgMbufTotalSpace();

   777 	Logger().WriteFormat(_L("Socket Server __DbgMbufTotalSpace returned %S"),&EpocErrorToText(err));

   778 	TInt err2 = ss.__DbgMbufFreeSpace();

   779 	Logger().WriteFormat(_L("Socket Server __DbgMbufTotalSpace returned %S"),&EpocErrorToText(err2));

   780 	if(err == KErrNone && err2 == KErrNone)

   781 		{

   782 		verdict = EPass;

   783 		}

   784 	ss.Close();

   785 	SetTestStepResult(verdict);

   786 	return verdict;

   787 #else

   788 	return EPass;

   789 #endif	

   790 	}

   791 

   792 

   793 // Test step Test

   794 const TDesC& CSocketServerTest24::GetTestName()

   795 	{

   796 	_LIT(cRet,"Test24");

   797 	return cRet;

   798 	}

   799 CSocketServerTest24::CSocketServerTest24()

   800 	{

   801 	}

   802 

   803 CSocketServerTest24::~CSocketServerTest24()

   804 	{

   805 	}

   806 

   807 enum TVerdict CSocketServerTest24::InternalDoTestStepL( void )

   808  // Verify that dbg functions without DEBUG_SOCKET_FUNCTIONS don't cause panic

   809  

   810 	{

   811 #ifndef _DEBUG_SOCKET_FUNCTIONS

   812 	Logger().WriteFormat(_L("_DEBUG_SOCKET_FUNCTIONS has not been defined"));

   813 	Logger().WriteFormat(_L("Verifying _Dbg functions do not crash OS"));

   814 	// Arbitarty pool limit

   815 	const TInt KPoolLimit = 10;

   816 	// const number 0

   817 	const TInt KZero = 0;

   818 	// next MBuf to fail 

   819 	const TInt KFailNextOne = 1;

   820 	TVerdict verdict = EPass;

   821 	TInt err;

   822 	RSocketServ ss;

   823 	err = ss.Connect();

   824 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   825 	if (err != KErrNone)

   826 		{

   827 		return EFail;

   828 		}

   829 	err = ss.__DbgSetMbufPoolLimit(KPoolLimit);

   830 	Logger().WriteFormat(_L("Socket Server __DbgSetMbufPoolLimit returned %S"),&EpocErrorToText(err));

   831 	// Fail next MBuf

   832 	TInt err2 = ss.__DbgFailNextMbuf(KFailNextOne);

   833 	Logger().WriteFormat(_L("Socket Server __DbgFailNextMbuf returned %S"),&EpocErrorToText(err2));

   834 	if(err == KErrNone && err2 == KErrNone)

   835 		{

   836 		verdict = EPass;

   837 		}

   838 	ss.Close();

   839 	SetTestStepResult(verdict);

   840 	return verdict;

   841 #else

   842 	return EPass;

   843 #endif	

   844 	}

   845 

   846 

   847 // Test step Test

   848 const TDesC& CSocketServerTest25::GetTestName()

   849 	{

   850 	_LIT(cRet,"Test25");

   851 	return cRet;

   852 	}

   853 CSocketServerTest25::CSocketServerTest25()

   854 	{

   855 	}

   856 

   857 CSocketServerTest25::~CSocketServerTest25()

   858 	{

   859 	}

   860 

   861 enum TVerdict CSocketServerTest25::InternalDoTestStepL( void )

   862 /* Simple test to verify __HeapChecking Functionality

   863  */

   864 	{

   865 #ifdef _DEBUG_SOCKET_FUNCTIONS	

   866 	// arbitary pool limit

   867 	const TInt KPoolLimit = 10;

   868 	TVerdict verdict = EFail;

   869 	TInt err;

   870 	RSocketServ ss;

   871 	err = ss.Connect();

   872 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   873 	if (err != KErrNone)

   874 		{

   875 		return EFail;

   876 		}

   877 	err = ss.__DbgSetMbufPoolLimit(KPoolLimit);

   878 	Logger().WriteFormat(_L("Socket Server __DbgSetMbufPoolLimit returned %S"),&EpocErrorToText(err));

   879 	if(err == KErrNone)

   880 		{

   881 		verdict = EPass;

   882 		}

   883 	SetTestStepResult(verdict);

   884 	ss.Close();

   885 	return verdict;

   886 #else

   887 	return EPass;

   888 #endif

   889 	}

   890 

   891 

   892 // Test step Test

   893 const TDesC& CSocketServerTest26::GetTestName()

   894 	{

   895 	_LIT(cRet,"Test26");

   896 	return cRet;

   897 	}

   898 	

   899 CSocketServerTest26::CSocketServerTest26()

   900 	{

   901 	}

   902 

   903 CSocketServerTest26::~CSocketServerTest26()

   904 	{

   905 	}

   906 

   907 enum TVerdict CSocketServerTest26::InternalDoTestStepL( void )

   908 /* Simple test to verify __DbgCheckMbuf

   909  */

   910 	{

   911 	// arbitarty pool limit

   912 	const TInt KPoolLimit = 10;

   913 	TVerdict verdict = EFail;

   914 	TInt err;

   915 	RSocketServ ss;

   916 	err = ss.Connect();

   917 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   918 	if (err != KErrNone)

   919 		{

   920 		return EFail;

   921 		}

   922 #ifdef _DEBUG_SOCKET_FUNCTIONS

   923 	RSocket sock;

   924 	TInt ret = sock.Open(ss, _L("Dummy Protocol 3"));

   925 	Logger().WriteFormat(_L("Socket Open returned %S"),&EpocErrorToText(err));

   926 	if(ret != KErrNone )

   927 		{

   928 		return EFail;

   929 		}

   930 	// Set the Mbuf pool limit to 0

   931 	err = ss.__DbgCheckMbuf(KPoolLimit);

   932 	Logger().WriteFormat(_L("__DbgCheckMbuf returned %S"),&EpocErrorToText(err));

   933 	if(err == KErrNone)

   934 		{

   935 		verdict = EPass;

   936 		}

   937 	sock.Close();

   938 	ss.Close();

   939 	SetTestStepResult(verdict);

   940 	return verdict;

   941 #else

   942 	verdict = ss.__DbgCheckMbuf(KPoolLimit) == KErrNone ? EPass : EFail;

   943 	SetTestStepResult(verdict);

   944 	ss.Close();

   945 	return verdict;

   946 #endif

   947 	}

   948 

   949 

   950 

   951 // Test step Test

   952 const TDesC& CSocketServerTest27::GetTestName()

   953 	{

   954 	_LIT(cRet,"Test27");

   955 	return cRet;

   956 	}

   957 CSocketServerTest27::CSocketServerTest27()

   958 	{

   959 	}

   960 

   961 CSocketServerTest27::~CSocketServerTest27()

   962 	{

   963 	}

   964 

   965 enum TVerdict CSocketServerTest27::InternalDoTestStepL( void )

   966 /* Simple test to verify __DbgFailNextMbuf

   967  */

   968 	{

   969 	// The next number of MBufs to fail

   970 	const TInt KMbufFailures = 1;

   971 	TVerdict verdict = EFail;

   972 	TInt err;

   973 	RSocketServ ss;

   974 	err = ss.Connect();

   975 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

   976 	if (err != KErrNone)

   977 		{

   978 		return EFail;

   979 		}

   980 	CleanupClosePushL(ss);

   981 #ifdef _DEBUG_SOCKET_FUNCTIONS	

   982 	// Open UDP socket

   983 	RSocket socket;

   984 	TInt ret = socket.Open(ss,KAfInet,KSockDatagram,KProtocolInetUdp);

   985 	Logger().WriteFormat(_L("Socket open returned %S"),&EpocErrorToText(ret));

   986 	if (ret != KErrNone)

   987 		{

   988 		return EFail;

   989 		}

   990 	CleanupClosePushL(socket);

   991 	TInetAddr local;

   992 	// arbitary port numbers

   993 	const TUint KLocalPort = 3442;

   994 	const TUint KDestPort = KLocalPort;

   995 	

   996 	// loop back addresses used for UDP send

   997 	_LIT(KLoopbackAddr, "127.0.0.1");

   998 	_LIT(KLocalAddr, "0.0.0.0");

   999 	local.SetPort(KLocalPort);

  1000 	local.Input(KLocalAddr);

  1001 	socket.Bind(local);

  1002     

  1003     TInetAddr dstAddr;

  1004     dstAddr.SetPort(KDestPort);

  1005     dstAddr.Input(KLoopbackAddr);

  1006     

  1007     // connect socket to loopback addr

  1008     TRequestStatus connectStatus;		

  1009 	socket.Connect(dstAddr, connectStatus);

  1010 	User::WaitForRequest(connectStatus);

  1011 	Logger().WriteFormat(_L("Socket connect returned %d"),connectStatus.Int());

  1012 	if(connectStatus.Int() != KErrNone)

  1013 		{

  1014 		return EFail;

  1015 		}

  1016 		

  1017 	// send some socket data

  1018 	_LIT8(data, "some arbitary send data");

  1019 	err = ss.__DbgFailNextMbuf(KMbufFailures);

  1020 	Logger().WriteFormat(_L("Socket Server __DbgFailNextMbuf returned %S"),&EpocErrorToText(err));

  1021 	if(err == KErrNone)

  1022 		{

  1023 		return EFail;

  1024 		}

  1025 	

  1026 	// wait for send to return, make sure __DbgFailNextMbuf did not effect outcome

  1027 	TRequestStatus sendStatus;

  1028 	socket.Send(data, 0, sendStatus);

  1029 	User::WaitForRequest(sendStatus);

  1030 	Logger().WriteFormat(_L("Socket send returned %S"),&EpocErrorToText(sendStatus.Int()));

  1031 	if(sendStatus == KErrNone)

  1032 		{

  1033 		verdict = EPass;

  1034 		}

  1035 	

  1036 	CleanupStack::PopAndDestroy(&socket);

  1037 	CleanupStack::PopAndDestroy(&ss);

  1038 	SetTestStepResult(verdict);

  1039 	return verdict;		

  1040 #else

  1041 	verdict =  ss.__DbgFailNextMbuf(KMbufFailures) == KErrNone ? EPass : EFail;

  1042 	CleanupStack::PopAndDestroy(&ss);

  1043 	return verdict;

  1044 #endif

  1045 	}

  1046 

  1047 // Test step Test

  1048 const TDesC& CSocketServerTest28::GetTestName()

  1049 	{

  1050 	_LIT(cRet,"Test28");

  1051 	return cRet;

  1052 	}

  1053 CSocketServerTest28::CSocketServerTest28()

  1054 	{

  1055 	}

  1056 

  1057 CSocketServerTest28::~CSocketServerTest28()

  1058 	{

  1059 	}

  1060 

  1061 enum TVerdict CSocketServerTest28::InternalDoTestStepL( void )

  1062 /* Simple test to check InstallExtension API

  1063  */

  1064 	{

  1065 	Logger().WriteFormat(_L("Attempting to install an ESOCK extension that Doesn't exist"));

  1066 	TVerdict verdict = EFail;

  1067 	TInt err;

  1068 	RSocketServ ss;

  1069 	err = ss.Connect();

  1070 	Logger().WriteFormat(_L("Socket Server Connect returned %S"),&EpocErrorToText(err));

  1071 	if (err != KErrNone)

  1072 		{

  1073 		return EFail;

  1074 		}

  1075 	

  1076 	// bad extension args to pass to SS

  1077 	_LIT(KBadExtensionName, "bad extension");

  1078 	_LIT(KBadArguments, "bad Arguments");

  1079 	TPtrC badPtr(KBadArguments);

  1080 	err = ss.InstallExtension(KBadExtensionName, badPtr);

  1081 	// Install Extension is an unsupported API

  1082 	if(err == KErrNotSupported)

  1083 		{

  1084 		verdict = EPass;

  1085 		}

  1086 	ss.Close();

  1087 	SetTestStepResult(verdict);

  1088 	return verdict;

  1089 	}

  1090 

  1091 // Test step 29

  1092 const TDesC& CSocketServerTest29::GetTestName()

  1093     {

  1094     _LIT(cRet,"Test29");

  1095     return cRet;

  1096     }

  1097 

  1098 class RSocketServerAttacker : public RSessionBase

  1099 /**

  1100 * General session class used to connect to socket server by name and send

  1101 * malicious message to it.

  1102 */

  1103     {

  1104 public:

  1105     TInt Connect()

  1106         {

  1107         return CreateSession(_L("!SocketServer"),TVersion(0,0,0));

  1108         }

  1109  

  1110     void TryToGetPaniced()

  1111         {

  1112         _LIT8(KDefaultText, "Default");

  1113  

  1114         TIpcArgs args;

  1115         args.Set(0,0); // Set invalid NULL descriptor pointer

  1116         args.Set(1,&KDefaultText);

  1117         args.Set(2,&KDefaultText);

  1118         args.Set(3,&KDefaultText);

  1119         SendReceive(ESSNumProtocols, args);

  1120         }

  1121     };

  1122 

  1123 TInt CSocketServerTest29::PanicTestThread(TAny*)

  1124     {

  1125     RSocketServerAttacker t;

  1126     TInt r = t.Connect();

  1127     if (r == KErrNone)

  1128         t.TryToGetPaniced();

  1129     return r;

  1130     }

  1131 

  1132 enum TVerdict CSocketServerTest29::InternalDoTestStepL( void )

  1133     {

  1134     Logger().Write(_L("Socket Server Test 29"));

  1135