1 // Copyright (c) 2004-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 contains ESock Test cases from section 8

    15 // 

    16 //

    17 

    18 // EPOC includes

    19 #include <e32base.h>

    20 

    21 #include <es_sock_internal.h>

    22 

    23 // Test system includes

    24 #include "SocketTestSection8.h"

    25 #include "ES_DUMMY.H"

    26 

    27 

    28 // Test step 8.1

    29 const TDesC& CSocketTest8_1::GetTestName()

    30 	{

    31 	_LIT(ret,"Test8.1");

    32 	return ret;

    33 	}

    34 

    35 enum TVerdict CSocketTest8_1::InternalDoTestStepL( void )

    36 	{

    37 	TVerdict verdict = EPass;

    38 	

    39 	Logger().WriteFormat(_L("Test Purpose: Ioctl returns not started on null socket"));

    40 	

    41 	// connect to esock

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

    43     RSocketServ ss;

    44 	TInt ret = OptimalConnect(ss);

    45 	CleanupClosePushL(ss);

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

    47 	TESTL(KErrNone == ret);

    48 	

    49 	//PG 14/02/2001

    50 	//Added test for defect: TOD-4QLDXY - Ioctl on incorrectly opened socket crashes socket server.

    51 	Logger().WriteFormat(_L("Opening a socket with no protocol"));

    52 	RSocket socketNoProtoDefined;

    53 	ret = socketNoProtoDefined.Open(ss);

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

    55 	TESTL(KErrNone == ret);

    56 	

    57 	// see if it's started

    58 	Logger().WriteFormat(_L("Check Ioctl fails"));

    59 	TRequestStatus stat;

    60 	socketNoProtoDefined.Ioctl(KDummyIoctlCheckStarted, stat);

    61 	User::WaitForRequest(stat);

    62 	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

    63 	TESTL(KErrNotSupported == stat.Int());

    64 	socketNoProtoDefined.Close();

    65 	

    66 	CleanupStack::Pop(&ss);

    67 	ss.Close();

    68 	

    69 	SetTestStepResult(verdict);

    70 	return verdict;

    71 	}

    72 

    73 // Test step 8.2

    74 const TDesC& CSocketTest8_2::GetTestName()

    75 	{

    76 	_LIT(ret,"Test8.2");

    77 	return ret;

    78 	}

    79 

    80 enum TVerdict CSocketTest8_2::InternalDoTestStepL( void )

    81 	{

    82 	TVerdict verdict = EPass;

    83 	

    84 	Logger().WriteFormat(_L("Test Purpose: Ioctl observes InternalOptionBit"));

    85 	

    86 	// connect to esock

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

    88     RSocketServ ss;

    89 	TInt ret = OptimalConnect(ss);

    90 	CleanupClosePushL(ss);

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

    92 	TESTL(KErrNone == ret);

    93 	

    94 	// get a protocol

    95 	Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));

    96 	TProtocolDesc protoInfo;

    97 	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

    98 	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));

    99 	TESTL(KErrNone == ret);

   100 	

   101 	// check internal options bit

   102 	RSocket socket;

   103 	Logger().WriteFormat(_L("Opening a new socket"));

   104 	ret = socket.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

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

   106 	TESTL(KErrNone == ret);

   107 	

   108 	Logger().WriteFormat(_L("Trying Ioctl on internal options bit"));

   109 	TRequestStatus stat;

   110 	socket.Ioctl(KInternalIoctlBit, stat);

   111 	User::WaitForRequest(stat);

   112 	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

   113 	TESTL(KErrAccessDenied == stat.Int());

   114 	

   115 	Logger().WriteFormat(_L("Trying to SetOpt internal options bit"));

   116 	ret = socket.SetOpt(KSocketInternalOptionBit, KSOLSocket);

   117 	Logger().WriteFormat(_L("SetOpt returned %S"), &EpocErrorToText(ret));

   118 	TESTL(KErrAccessDenied == ret);

   119 	

   120 	Logger().WriteFormat(_L("Trying to GetOpt internal options bit"));

   121 	TPckgBuf<TBool> boolean;

   122 	ret = socket.GetOpt(KSocketInternalOptionBit, KSOLSocket, boolean);

   123 	Logger().WriteFormat(_L("GetOpt returned %S"), &EpocErrorToText(ret));

   124 	TESTL(KErrAccessDenied == ret);

   125 	

   126 	Logger().WriteFormat(_L("Testing StartL() with Ioctl KDummyIoctlCheckStarted"));

   127 	socket.Ioctl(KDummyIoctlCheckStarted, stat, NULL, KIoctlDummyLevel);

   128 	User::WaitForRequest(stat);

   129 	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

   130 	TESTL(KErrNone == stat.Int());

   131 	

   132 	CleanupStack::Pop(&ss);

   133 	ss.Close();

   134 	

   135 	SetTestStepResult(verdict);

   136 	return verdict;

   137 	}

   138 

   139 // Test step 8.3

   140 const TDesC& CSocketTest8_3::GetTestName()

   141 	{

   142 	_LIT(ret,"Test8.3");

   143 	return ret;

   144 	}

   145 

   146 enum TVerdict CSocketTest8_3::InternalDoTestStepL( void )

   147 	{

   148 	TVerdict verdict = EPass;

   149 	

   150 	Logger().WriteFormat(_L("Test Purpose: Ioctl auto bind and check started"));

   151 	

   152 	// connect to esock

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

   154     RSocketServ ss;

   155 	TInt ret = OptimalConnect(ss);

   156 	CleanupClosePushL(ss);

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

   158 	TESTL(KErrNone == ret);

   159 	

   160 	// get a protocol

   161 	Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));

   162 	TProtocolDesc protoInfo;

   163 	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

   164 	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));

   165 	TESTL(KErrNone == ret);

   166 	

   167 	Logger().WriteFormat(_L("Opening a new socket"));

   168 	RSocket socket;

   169 	ret = socket.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

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

   171 	TESTL(KErrNone == ret);

   172 	

   173 	Logger().WriteFormat(_L("Testing StartL() with Ioctl KDummyIoctlCheckStarted"));

   174 	TRequestStatus stat;

   175 	socket.Ioctl(KDummyIoctlCheckStarted, stat, NULL, KIoctlDummyLevel);

   176 	User::WaitForRequest(stat);

   177 	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

   178 	TESTL(KErrNone == stat.Int());

   179 	

   180 	Logger().WriteFormat(_L("Testing AutoBind()"));

   181 	TSockAddr addr;

   182 	Logger().WriteFormat(_L("Trying to Connect socket"));

   183 	socket.Connect(addr, stat);

   184 	User::WaitForRequest(stat);

   185 	Logger().WriteFormat(_L("Connect returned with status %S"), &EpocErrorToText(stat.Int()));

   186 	TESTL(KErrNone == stat.Int());

   187 	

   188 	Logger().WriteFormat(_L("Checking bound status with Ioctl"));

   189 	socket.Ioctl(KDummyIoctlCheckBound, stat, NULL, KIoctlDummyLevel);

   190 	User::WaitForRequest(stat);

   191 	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

   192 	TESTL(KErrNone == stat.Int());

   193 	

   194 	CleanupStack::Pop(&ss);

   195 	ss.Close();

   196 	

   197 	SetTestStepResult(verdict);

   198 	return verdict;

   199 	}

   200 

   201 // Test step 8.4

   202 const TDesC& CSocketTest8_4::GetTestName()

   203 	{

   204 	_LIT(ret,"Test8.4");

   205 	return ret;

   206 	}

   207 

   208 enum TVerdict CSocketTest8_4::InternalDoTestStepL( void )

   209 	{

   210 	TVerdict verdict = EPass;

   211 	

   212 	Logger().WriteFormat(_L("Test Purpose: Ioctl Get and Set Options"));

   213 	

   214 	// connect to esock

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

   216     RSocketServ ss;

   217 	TInt ret = OptimalConnect(ss);

   218 	CleanupClosePushL(ss);

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

   220 	TESTL(KErrNone == ret);

   221 	

   222 	// try SetLocalPort

   223 	Logger().WriteFormat(_L("Opening a socket"));

   224 	RSocket socket;

   225 	ret = socket.Open(ss, _L("Dummy Protocol 1"));

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

   227 	TESTL(KErrNone == ret);

   228 	

   229 	Logger().WriteFormat(_L("Trying SetLocalPort to 666"));

   230 	ret = socket.SetLocalPort(666);

   231 	Logger().WriteFormat(_L("SetLocalPort returned %S"), &EpocErrorToText(ret));

   232 	TESTL(KErrNone == ret);

   233 	Logger().WriteFormat(_L("Port now set to %d"), socket.LocalPort());

   234 	TESTL(666 == socket.LocalPort());

   235 	

   236 	// try blocking Get/Set

   237 	Logger().WriteFormat(_L("Testing blocking mode Get and Set options"));

   238 	Logger().WriteFormat(_L("Trying to SetOption KSONonBlockingIO"));

   239 	ret = socket.SetOpt(KSONonBlockingIO, KSOLSocket);

   240 	Logger().WriteFormat(_L("SetOption returned %S"), &EpocErrorToText(ret));

   241 	TESTL(KErrNone == ret);

   242 	

   243 	Logger().WriteFormat(_L("Trying to GetOption KSONonBlockingIO"));

   244 	TPckgBuf<TBool> boolean;

   245 	ret = socket.GetOpt(KSONonBlockingIO, KSOLSocket, boolean);

   246 	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 

   247 		&EpocErrorToText(ret), boolean());

   248 	TESTL(KErrNone == ret);

   249 	TESTL(TRUE == boolean());

   250 	

   251 	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));

   252 	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);

   253 	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 

   254 		&EpocErrorToText(ret), boolean());

   255 	TESTL(KErrNone == ret);

   256 	TESTL(FALSE == boolean());

   257 	

   258 	Logger().WriteFormat(_L("Trying to SetOption KSOBlockingIO"));

   259 	ret = socket.SetOpt(KSOBlockingIO, KSOLSocket);

   260 	Logger().WriteFormat(_L("SetOption returned %S"), &EpocErrorToText(ret));

   261 	TESTL(KErrNone == ret);

   262 	

   263 	Logger().WriteFormat(_L("Trying to GetOption KSONonBlockingIO"));

   264 	ret = socket.GetOpt(KSONonBlockingIO, KSOLSocket, boolean);

   265 	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 

   266 		&EpocErrorToText(ret), boolean());

   267 	TESTL(KErrNone == ret);

   268 	TESTL(FALSE == boolean());

   269 	

   270 	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));

   271 	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);

   272 	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 

   273 		&EpocErrorToText(ret), boolean());

   274 	TESTL(KErrNone == ret);

   275 	TESTL(TRUE == boolean());

   276 	

   277 	CleanupStack::Pop(&ss);

   278 	ss.Close();

   279 	

   280 	return verdict;

   281 	}

   282 

   283 // Test step 8.5

   284 const TDesC& CSocketTest8_5::GetTestName()

   285 	{

   286 	_LIT(ret,"Test8.5");

   287 	return ret;

   288 	}

   289 

   290 enum TVerdict CSocketTest8_5::InternalDoTestStepL( void )

   291 	{

   292 	TVerdict verdict = EPass;

   293 	

   294 	Logger().WriteFormat(_L("Test Purpose: Ioctl returns not started on null socket"));

   295 	

   296 	// connect to esock

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

   298     RSocketServ ss;

   299 	TInt ret = OptimalConnect(ss);

   300     CleanupClosePushL(ss);

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

   302 	TESTL(KErrNone == ret);

   303 	

   304 	// Added test for defect: DEF043787 	SAP never gets told to cancel an Ioctl if client calls RSocket::CancelAll().

   305 	_LIT(KSomeProtocol, "Dummy Protocol 1");

   306 	RSocket socket;

   307 	ret = socket.Open(ss, KSomeProtocol);

   308 	CleanupClosePushL(socket);

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

   310 	TESTL(KErrNone == ret);

   311 	

   312 	// Do test IOCTL thats never completes, then cancel it

   313 	Logger().WriteFormat(_L("Do IOCTL/CancelALL."));

   314 	TRequestStatus stat;

   315 	socket.Ioctl(KDummyIoctlIgnore, stat);

   316 	socket.CancelAll();

   317 	User::WaitForRequest(stat);

   318 	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

   319 	TESTL(KErrCancel == stat.Int());

   320 	

   321 	// Now query for the result of the previous IOCtl.

   322 	socket.Ioctl(KDummyIoctlCancelled, stat);

   323 	User::WaitForRequest(stat);

   324 	if(stat==KErrNotFound)

   325 		{

   326 		Logger().WriteFormat(_L("Ioctl returned with status %S: CancelAll failed to cancel previous IOCTL."), &EpocErrorToText(stat.Int()));

   327 		}

   328 	else

   329 		{

   330 		Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));

   331 		}

   332 	TESTL(KErrNone == stat.Int());

   333 	

   334 	CleanupStack::PopAndDestroy(2,&ss); // socket, ss

   335 	SetTestStepResult(verdict);

   336 	return verdict;

   337 	}

   338 	

   339 const TDesC &CSocketTest8_6::GetTestName()

   340 	{

   341 	_LIT(ret,"Test8.6");

   342 	return ret;

   343 	}

   344 	

   345 enum TVerdict CSocketTest8_6::InternalDoTestStepL( void )

   346 	{

   347 	TVerdict verdict = EPass;

   348 	

   349 	Logger().WriteFormat(_L("Test Purpose: Retention of socket options from before Accept to after Accept"));

   350 	

   351 	// connect to esock

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

   353     RSocketServ ss1;

   354 	TInt ret = OptimalConnect(ss1);

   355 	TESTL(KErrNone == ret);

   356 	CleanupClosePushL(ss1);

   357 	

   358 	Logger().WriteFormat(_L("Opening Socket on pdummy3"));

   359 	RSocket sock1;

   360 	ret = sock1.Open(ss1,_L("Dummy Protocol 3"));

   361 	TESTL(KErrNone == ret);

   362 	

   363 	Logger().WriteFormat(_L("Binding Sock1"));

   364 	TSockAddr addr;

   365 	ret = sock1.Bind(addr);

   366 	TESTL(KErrNone == ret);

   367 	

   368 	Logger().WriteFormat(_L("Listening on Sock1"));

   369 	ret = sock1.Listen(5);

   370 	TESTL(KErrNone == ret);

   371 	

   372 	Logger().WriteFormat(_L("Opening a null Socket"));

   373 	RSocket nullSock;

   374 	nullSock.Open(ss1);

   375 	TESTL(KErrNone == ret);

   376 	

   377 	const TUint KBufferSize = 1024;

   378 	Logger().WriteFormat(_L("Setting a whole bunch of KSOLSocket options on the parent (sock1) socket"));

   379 	ret = sock1.SetOpt(KSOSendBuf, KSOLSocket, KBufferSize);

   380 	TESTL(KErrNone == ret);

   381 	ret = sock1.SetOpt(KSORecvBuf, KSOLSocket, KBufferSize);

   382 	TESTL(KErrNone == ret);

   383 	ret = sock1.SetOpt(KSODebug, KSOLSocket, ETrue);

   384 	TESTL(KErrNone == ret);

   385 	ret = sock1.SetOpt(KSONonBlockingIO, KSOLSocket);

   386 	TESTL(KErrNone == ret);

   387 	_LIT_SECURITY_POLICY_C2(KProcPolicy, ECapabilityNetworkServices, ECapabilityNetworkControl);

   388 	ret = nullSock.SetOpt(KSOEnableTransfer, KSOLSocket, KProcPolicy().Package());

   389 	TESTL(KErrNotReady == ret);

   390 	

   391 	Logger().WriteFormat(_L("Now simulating a remote connection to complete the accept"));

   392 	ret = sock1.SetOpt(KDummyOptionSetConnectComplete, KIoctlDummyLevel);

   393 	TESTL(KErrNone == ret);

   394 	Logger().WriteFormat(_L("Now performing accept"));

   395 	TRequestStatus stat;

   396 	sock1.Accept(nullSock, stat);

   397 	User::WaitForRequest(stat);

   398 	TESTL(KErrNone == stat.Int());

   399 	

   400 	Logger().WriteFormat(_L("Now retrieving all the options set on the null socket with getOpts"));

   401 	TInt retrievedOpt;

   402 	ret = nullSock.GetOpt(KSOSendBuf, KSOLSocket, retrievedOpt);

   403 	TESTL(KErrNone == ret);

   404 	if (retrievedOpt != KBufferSize)

   405 		{

   406 		Logger().WriteFormat(_L("Opt KSOSendBuf did not return the correct value"));

   407 		User::Leave(EFail);

   408 		}	

   409 	ret = nullSock.GetOpt(KSORecvBuf, KSOLSocket, retrievedOpt);

   410 	TESTL(KErrNone == ret);

   411 	if (retrievedOpt != KBufferSize)

   412 		{

   413 		Logger().WriteFormat(_L("Opt KSORecvBuf did not return the correct value"));

   414 		User::Leave(EFail);

   415 		}	

   416 	ret = nullSock.GetOpt(KSODebug, KSOLSocket, retrievedOpt);

   417 	TESTL(KErrNone == ret);

   418 	if (!retrievedOpt) 

   419 		{

   420 		Logger().WriteFormat(_L("Opt KSODebug did not return the correct value"));

   421 		User::Leave(EFail);

   422 		}

   423 	ret = nullSock.GetOpt(KSONonBlockingIO, KSOLSocket, retrievedOpt);

   424 	TESTL(KErrNone == ret);

   425 	if (!retrievedOpt)

   426 		{

   427 		Logger().WriteFormat(_L("Opt KSONonBlockingIO did not return the correct value"));

   428 		User::Leave(EFail);

   429 		}

   430 	

   431 	CleanupStack::Pop(&ss1);

   432 	ss1.Close();

   433 	

   434 	return verdict;

   435 	}

   436 

   437 const TDesC &CSocketTest8_7::GetTestName()

   438 	{

   439 	_LIT(ret,"Test8.7");

   440 	return ret;

   441 	}

   442 

   443 enum TVerdict CSocketTest8_7::InternalDoTestStepL( void )

   444 	{

   445 	TVerdict verdict = EPass;

   446 	

   447 	Logger().WriteFormat(_L("Test Purpose: getOpt with small client buffer"));

   448 	

   449 	// connect to esock

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

   451     RSocketServ ss;

   452 	TInt ret = OptimalConnect(ss);

   453 	CleanupClosePushL(ss);

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

   455 	TESTL(KErrNone == ret);

   456 	

   457 	// try SetLocalPort

   458 	Logger().WriteFormat(_L("Opening a socket"));

   459 	RSocket socket;

   460 	ret = socket.Open(ss, _L("Dummy Protocol 1"));

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

   462 	TESTL(KErrNone == ret);

   463 	

   464 	// try with small buffer - 8 bit descriptor

   465 	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));

   466 	TBuf8<1> smallBuf8;

   467 	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, smallBuf8);

   468 	Logger().WriteFormat(_L("GetOption returned %S"),&EpocErrorToText(ret));

   469 	TESTL(KErrOverflow == ret);

   470 		

   471 	// try with correct size descriptor

   472 	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));

   473 	TPckgBuf<TBool> boolean;

   474 	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);

   475 	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 

   476 			&EpocErrorToText(ret), boolean());

   477 	TESTL(KErrNone == ret);

   478 	TESTL(TRUE == boolean());

   479 		

   480 	CleanupStack::Pop(&ss);

   481 	ss.Close();

   482 	

   483 	return verdict;

   484 	}

   485 

   486 const TDesC &CSocketTest8_8::GetTestName()

   487 	{

   488 	_LIT(ret,"Test8.8");

   489 	return ret;

   490 	}

   491 

   492 enum TVerdict CSocketTest8_8::InternalDoTestStepL( void )

   493 	{

   494 	TVerdict verdict = EPass;

   495 

   496 	Logger().WriteFormat(_L("Test Purpose: KSOSelectLastError option update"));

   497 	RSocketServ ss;

   498 	TInt ret=OptimalConnect(ss);

   499 	CleanupClosePushL(ss);

   500     TESTL(KErrNone == ret);	

   501     

   502 	Logger().WriteFormat(_L("Open by name"));             

   503 	RSocket sock, sock2;                                                    

   504 	ret=sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable                         

   505 	TESTL(KErrNone == ret);	

   506 

   507 	// get last error - check that option value is updated

   508   	TInt val;

   509    	ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);

   510    	Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));	

   511    	TESTL(KErrNone == ret);

   512    	// return value should match the updated value

   513    	TESTL (val == ret);

   514 

   515 	ret=sock2.Open(ss); // null socket to accept onto                         

   516 	TESTL(KErrNone == ret);	

   517 	

   518 	Logger().WriteFormat(_L("Set test option"));             

   519 	const TInt KExpectedError = -4567; // Something random.

   520 	ret=sock.SetOpt(KDummyOptionSetErrorNextListen,0,KExpectedError);

   521 	TESTL(KErrNone == ret);	

   522 	

   523 	TSockAddr addr;

   524 	ret=sock.Bind(addr);

   525 	TESTL(KErrNone == ret);	

   526 	

   527 	Logger().WriteFormat(_L("Listen"));             

   528 	ret=sock.Listen(0); // No need for a que

   529 	TESTL(KErrNone == ret);	

   530 	

   531 	Logger().WriteFormat(_L("Accept - error"));             

   532 	TRequestStatus rstat;

   533 	sock.Accept(sock2, rstat);

   534 	User::WaitForRequest(rstat);

   535 	TESTL(rstat.Int() == KExpectedError);	

   536 	

   537 	// get last error

   538    	ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);

   539    	Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));	

   540    	TESTL(KExpectedError == ret);

   541    	// return value should match the updated value

   542    	TESTL(val == ret);

   543 	

   544 	// Clears last error

   545    	ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);

   546    	Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));	

   547    	TESTL(KErrNone == ret);	

   548    	// return value should match the updated value

   549    	TESTL(val == ret);

   550    	

   551 	CleanupStack::Pop(&ss);

   552 	ss.Close();

   553 	

   554 	SetTestStepResult(verdict);

   555 	return verdict;

   556 	}

   557 

   558