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

    15 // 

    16 //

    17 

    18 // EPOC includes

    19 #include <e32base.h>

    20 #include <ss_std.h>

    21 

    22 // Test system includes

    23 #include "SocketTestSection1.h"

    24 

    25 

    26 _LIT(KDummyProtocol1Name,"Dummy Protocol 1"); // corresponds to KDummyOneName in pdummy

    27 

    28 // Test step 1.1

    29 const TDesC& CSocketTest1_1::GetTestName()

    30 	{

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

    32 	return ret;

    33 	}

    34 

    35 enum TVerdict CSocketTest1_1::InternalDoTestStepL( void )

    36 	{

    37 	TVerdict verdict = EPass;

    38 

    39 	Logger().WriteFormat(_L("Test Purpose: Connect and Disconnect"));

    40 

    41 	// connect to esock

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

    43     RSocketServ ss1;

    44 	TInt ret = OptimalConnect(ss1);

    45 	CleanupClosePushL(ss1);

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

    47 	TESTL(KErrNone == ret);

    48 

    49 	Logger().WriteFormat(_L("Closing Session"));

    50 	CleanupStack::Pop(&ss1);

    51 	ss1.Close();

    52 

    53 	Logger().WriteFormat(_L("Re-connecting to socket server"));

    54     RSocketServ ss;

    55 	ret = OptimalConnect(ss);

    56 	CleanupClosePushL(ss);

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

    58 	TESTL(KErrNone == ret);

    59 

    60 	CleanupStack::Pop();

    61 	ss.Close();

    62  

    63  	SetTestStepResult(verdict);   

    64 	return verdict;

    65 	}

    66 

    67 

    68 // Test step 1.2

    69 const TDesC& CSocketTest1_2::GetTestName()

    70 	{

    71 	_LIT(ret,"Test1.2");

    72 	return ret;

    73 	}

    74 	

    75 enum TVerdict CSocketTest1_2::InternalDoTestStepL( void )

    76 	{

    77 	TVerdict verdict = EPass;

    78 

    79 	Logger().WriteFormat(_L("Test Purpose: Open and Close Sockets"));

    80 

    81 	// connect to esock

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

    83     RSocketServ ss;

    84 	TInt ret = OptimalConnect(ss);

    85 	CleanupClosePushL(ss);

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

    87 	TESTL(KErrNone == ret);

    88 

    89 	// NumProtocols and GetProtocolInfo

    90 	Logger().WriteFormat(_L("Try NumProtocols"));

    91 //	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

    92 	TUint numProtocols;

    93 	ret = ss.NumProtocols(numProtocols);

    94 	Logger().WriteFormat(_L("NumProtocols returned %S, number %d"), 

    95 			&EpocErrorToText(ret), numProtocols);

    96 	TESTL(KErrNone == ret);

    97 

    98 	TProtocolDesc protoInfo;

    99 	TUint aIndex;

   100 	TBool aFound = false;

   101 	RSocket sock1;

   102 	TInt pdummyIndex = -1;

   103  	Logger().WriteFormat(_L("Trying GetProtocolInfo until Dummy Protocol 1 is found"));

   104 	for (aIndex=1;aIndex<=numProtocols;aIndex++) 

   105 		{

   106 		ret = ss.GetProtocolInfo(aIndex, protoInfo);

   107 		Logger().WriteFormat(_L("GetProtocolInfo returned %S"), &EpocErrorToText(ret));	

   108 		TESTL(KErrNone == ret || KErrCannotFindProtocol == ret);

   109 		Logger().WriteFormat(_L("Protocol Index %d corresponds to %S"), aIndex, &protoInfo.iName);

   110 		if (protoInfo.iName == KDummyProtocol1Name())

   111 			{

   112 			pdummyIndex = aIndex;

   113 			aFound = true;

   114 			}

   115 		}

   116 

   117 	if (!aFound) {

   118 		Logger().WriteFormat(_L("Could not find Dummy Protocol 1"));

   119 		CleanupStack::PopAndDestroy();

   120 		return EFail;

   121 	}

   122 

   123 	Logger().WriteFormat(_L("Opening Socket for Family: %d, Sock: %d, protocol: %d"),

   124 			protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

   125 		

   126 	ret=sock1.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

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

   128 	TESTL(KErrNone == ret);

   129 	Logger().WriteFormat(_L("Opened %S socket OK"), &protoInfo.iName);

   130 

   131 	Logger().WriteFormat(_L("Getting protocol info for index %d again"),pdummyIndex);

   132 	ret = ss.GetProtocolInfo(pdummyIndex, protoInfo);

   133 	Logger().WriteFormat(_L("GetProtocolInfo returned %S"), &EpocErrorToText(ret));

   134 	TESTL(KErrNone == ret);

   135 

   136 

   137 	Logger().WriteFormat(_L("Opening another socket"));

   138 	RSocket sock2;

   139 	ret = sock2.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

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

   141 	TESTL(KErrNone == ret);

   142 	Logger().WriteFormat(_L("Opened %S socket OK"), &protoInfo.iName);

   143 

   144 	Logger().WriteFormat(_L("Closing sockets"));

   145 	sock2.Close();

   146 	sock1.Close();

   147 

   148 	Logger().WriteFormat(_L("Opening another socket"));

   149 	RSocket sock3;

   150 	ret = sock3.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

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

   152 	TESTL(KErrNone == ret);

   153 	Logger().WriteFormat(_L("Opened %S socket OK"), &protoInfo.iName);

   154 

   155 	Logger().WriteFormat(_L("Closing socket"));

   156 	sock3.Close();

   157 

   158 	Logger().WriteFormat(_L("Opening a socket by name on dummy protocol 1"));

   159 	RSocket sock4;

   160 	ret = sock4.Open(ss, KDummyProtocol1Name());

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

   162 	TESTL(KErrNone == ret);

   163 	Logger().WriteFormat(_L("Opened %S socket OK"), &protoInfo.iName);

   164 

   165 	Logger().WriteFormat(_L("Closing socket"));

   166 	sock4.Close();

   167 

   168 	CleanupStack::Pop(&ss);

   169 	ss.Close();

   170 

   171 	SetTestStepResult(verdict);

   172 	return verdict;

   173 	}

   174 

   175 // Test step 1.3

   176 const TDesC& CSocketTest1_3::GetTestName()

   177 	{

   178 	_LIT(ret,"Test1.3");

   179 	return ret;

   180 	}

   181 

   182 

   183 enum TVerdict CSocketTest1_3::InternalDoTestStepL( void )

   184 	{

   185 	TVerdict verdict = EPass;

   186 

   187 	Logger().WriteFormat(_L("Test Purpose: Open Bad Socket Type"));

   188 

   189 	// connect to esock

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

   191     RSocketServ ss;

   192 	TInt ret = OptimalConnect(ss);

   193 	CleanupClosePushL(ss);

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

   195 	TESTL(KErrNone == ret);

   196 

   197 	Logger().WriteFormat(_L("Attempting to create bad socket type"));

   198 	RSocket sock;

   199 	ret = sock.Open(ss, 0, 0, 0); 

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

   201 	TESTL(KErrBadName == ret);

   202 

   203 	sock.Close();

   204 	CleanupStack::Pop(&ss);

   205 	ss.Close();

   206 	SetTestStepResult(verdict);

   207 	return verdict;

   208 	}

   209 

   210 // Test step 1.4

   211 const TDesC& CSocketTest1_4::GetTestName()

   212 	{

   213 	_LIT(ret,"Test1.4");

   214 	return ret;

   215 	}

   216 	

   217 enum TVerdict CSocketTest1_4::InternalDoTestStepL( void )

   218 	{

   219 	TVerdict verdict = EPass;

   220 

   221 	Logger().WriteFormat(_L("Test Purpose: Find Protocols"));

   222 

   223 	// connect to esock

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

   225     RSocketServ ss;

   226 	TInt ret = OptimalConnect(ss);

   227 	CleanupClosePushL(ss);

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

   229 	TESTL(KErrNone == ret);

   230 

   231     Logger().WriteFormat(_L("Try to find non-existent protocol"));

   232 	TProtocolDesc protoInfo;

   233 	ret = ss.FindProtocol(_L("Not a Protocol Name"), protoInfo);

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

   235 	TESTL(KErrNotFound == ret);

   236 

   237     Logger().WriteFormat(_L("Try to find dummy protocol 1"));

   238 	ret = ss.FindProtocol(KDummyProtocol1Name(), protoInfo);

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

   240 	TESTL(KErrNone == ret);

   241 	

   242 	CleanupStack::Pop(&ss);

   243 	ss.Close();

   244 	SetTestStepResult(verdict);

   245 	return verdict;

   246 	}

   247 

   248 // Test step 1.5

   249 const TDesC& CSocketTest1_5::GetTestName()

   250 	{

   251 	_LIT(ret,"Test1.5");

   252 	return ret;

   253 	}

   254 

   255 enum TVerdict CSocketTest1_5::InternalDoTestStepL( void )

   256 	{

   257 	TVerdict verdict = EPass;

   258 

   259 	Logger().WriteFormat(_L("Test Purpose: Tidy Up Sockets on Thread Death"));

   260 

   261 	Logger().WriteFormat(_L("Main thread : Creating sub thread"));

   262 	RSemaphore s;

   263 	s.CreateLocal(0);

   264 	RThread t;

   265 	TSocketThreadArg a;

   266 	a.iHandle = this;

   267 	a.iSem=&s;

   268 	a.iNumSockets = KNumTestSockets;

   269 	//Need to share logger across different threads

   270 	Logger().ShareAuto();

   271 	t.Create(_L("SocketThread1"), SocketThread, 

   272 			 KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, &a);

   273 	t.Resume();

   274 	s.Wait();

   275 

   276 	Logger().WriteFormat(_L("Main thread : Killing Sub thread"));

   277 	t.Kill(KErrNone);

   278 	t.Close();

   279 

   280 	SetTestStepResult(verdict);

   281 	return verdict;

   282 	}

   283 

   284 // Test step 1.6

   285 const TDesC& CSocketTest1_6::GetTestName()

   286 	{

   287 	_LIT(ret,"Test1.6");

   288 	return ret;

   289 	}

   290 	

   291 enum TVerdict CSocketTest1_6::InternalDoTestStepL( void )

   292 	{

   293 	TVerdict verdict = EPass;

   294 

   295 	Logger().WriteFormat(_L("Test Purpose: Close Uninitialised Socket"));

   296 

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

   298 	RSocket s;

   299 	s.Close();

   300 	s.Close();

   301 

   302 	return verdict;

   303 	}

   304 

   305 // Test step 1.7

   306 const TDesC& CSocketTest1_7::GetTestName()

   307 	{

   308 	_LIT(ret,"Test1.7");

   309 	return ret;

   310 	}

   311 	

   312 enum TVerdict CSocketTest1_7::InternalDoTestStepL( void )

   313 	{

   314 	TVerdict verdict = EPass;

   315 	

   316 	TInt numExhaustiveSockets = iNormalTest ? KNumExhaustiveSockets : 10;

   317 	iNormalTest = EFalse; // normal test is only run once, the rest are OOM tests

   318 

   319 	Logger().WriteFormat(_L("Test Purpose: Exhaustive Socket Open"));

   320 

   321 	// connect to esock

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

   323     RSocketServ ss;

   324 	TInt ret = OptimalConnect(ss);

   325 	CleanupClosePushL(ss);

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

   327 	TESTL(KErrNone == ret);

   328 

   329     Logger().WriteFormat(_L("Finding dummy protocol 1"));

   330 	TProtocolDesc protoInfo;

   331 	ret = ss.FindProtocol(KDummyProtocol1Name(), protoInfo);

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

   333 	TESTL(KErrNone == ret);

   334 

   335     Logger().WriteFormat(_L("Opening socket"));

   336 	RSocket sock;

   337 	ret = sock.Open(ss,protoInfo.iAddrFamily,protoInfo.iSockType,protoInfo.iProtocol);

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

   339 	TESTL(KErrNone == ret);

   340 

   341     Logger().WriteFormat(_L("Closing socket"));

   342 	sock.Close();

   343 

   344     Logger().WriteFormat(_L("Creating array of %d sockets"), numExhaustiveSockets);

   345 	RSocket* socks = new (ELeave) RSocket[numExhaustiveSockets];

   346 	CleanupArrayDeletePushL(socks);

   347 

   348 	Logger().WriteFormat(_L("Attempting to Open %d sockets"), numExhaustiveSockets);

   349 	TInt sockNum=0;

   350 	ret = KErrNone;

   351 	while (KErrNone==ret && sockNum<numExhaustiveSockets)

   352 		{

   353 		ret = socks[sockNum].Open(ss, protoInfo.iAddrFamily, 

   354 								  protoInfo.iSockType, protoInfo.iProtocol);

   355 		sockNum++;

   356 		}

   357 	if (ret != KErrNone)

   358 		{

   359 		sockNum--;

   360 		}

   361 	Logger().WriteFormat(_L("Created %d sockets"), sockNum);

   362 	

   363 	Logger().WriteFormat(_L("Freeing sockets in creation order"));

   364 	TInt i;

   365 	for (i=0; i<sockNum; i++)

   366 		{

   367 		socks[i].Close();

   368 		}

   369 		

   370 

   371 #if defined (_DEBUG_SOCKET_FUNCTIONS)

   372 

   373 	Logger().WriteFormat(_L("Attempting to Open %d sockets"), numExhaustiveSockets);

   374 	TInt sockCount1 = sockNum;

   375 	ret = KErrNone;

   376 	sockNum = 0;

   377 	while (ret==KErrNone && sockNum<numExhaustiveSockets)

   378 		{

   379 		ret=socks[sockNum].Open(ss, protoInfo.iAddrFamily, 

   380 								protoInfo.iSockType,protoInfo.iProtocol);

   381 		sockNum++;

   382 		}

   383 	if (ret != KErrNone)

   384 		{

   385 		sockNum--;

   386 		}

   387 	Logger().WriteFormat(_L("Created %d sockets, expected %d sockets"), sockNum, sockCount1);

   388 	TESTL(sockCount1 == sockNum);

   389 

   390 	Logger().WriteFormat(_L("Freeing sockets in creation order"));

   391 	for (i=0; i<sockNum; i++)

   392 		{

   393 		socks[i].Close();

   394 		}

   395 

   396 #endif	// (_DEBUG) }

   397 

   398 	CleanupStack::PopAndDestroy(socks);

   399 

   400 	CleanupStack::Pop(&ss);

   401 	ss.Close();

   402 	SetTestStepResult(verdict);

   403 	return verdict;

   404 	}

   405 	

   406 // Test step 1.8

   407 const TDesC& CSocketTest1_8::GetTestName()

   408 	{

   409 	_LIT(ret,"Test1.8");

   410 	return ret;

   411 	}

   412 	

   413 enum TVerdict CSocketTest1_8::InternalDoTestStepL( void )

   414 	{

   415 	TVerdict verdict = EPass;

   416 

   417 	Logger().WriteFormat(_L("Test Purpose: Exhaustively enumerate all the protocols"));

   418 

   419 	// connect to esock

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

   421     RSocketServ ss;

   422 	TInt ret = ss.Connect();

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

   424 	TESTL(KErrNone == ret);

   425 	CleanupClosePushL(ss);

   426 	// NumProtocols and GetProtocolInfo

   427 	Logger().WriteFormat(_L("Try NumProtocols"));

   428 	TUint numProtocols;

   429 	ret = ss.NumProtocols(numProtocols);

   430 	Logger().WriteFormat(_L("NumProtocols returned %S, number %d"), 

   431 			&EpocErrorToText(ret), numProtocols);

   432 	TESTL(KErrNone == ret);

   433 

   434 	TProtocolDesc protoInfo;

   435 	TUint aIndex;

   436 	TInt pdummyIndex = -1;

   437  	Logger().WriteFormat(_L("Trying GetProtocolInfo on each protocol"));

   438 	for (aIndex=1;aIndex<=numProtocols;aIndex++) 

   439 		{

   440 		ret = ss.GetProtocolInfo(aIndex, protoInfo);

   441 		Logger().WriteFormat(_L("GetProtocolInfo returned %S"), &EpocErrorToText(ret));	

   442 		TESTL(KErrNone == ret);

   443 		Logger().WriteFormat(_L("Protocol Index %d corresponds to %S"), aIndex, &protoInfo.iName);

   444 		if (protoInfo.iName ==KDummyProtocol1Name())

   445 			{

   446 			pdummyIndex = aIndex;

   447 			}

   448 		}

   449 	CleanupStack::Pop(&ss);

   450 	ss.Close();

   451 	if (pdummyIndex < 0)

   452 		{

   453 		Logger().WriteFormat(_L("Could not find Dummy Protocol 1"));

   454 		verdict = EFail;

   455 		}

   456 	verdict = EPass;

   457 	

   458 	SetTestStepResult(verdict);

   459 	return verdict;

   460 	}

   461 

   462 

   463 

   464 

   465 

   466 

   467 

   468 // Test step 1.9

   469 const TDesC& CSocketTest1_9::GetTestName()

   470 	{

   471 	_LIT(ret,"Test1.9");

   472 	return ret;

   473 	}

   474 	

   475 	

   476 enum TVerdict CSocketTest1_9::InternalDoTestStepL( void )

   477 	{

   478 

   479 	// Create socket, shutdown socket then connect 

   480 	TVerdict verdict = EPass;

   481 	Logger().WriteFormat(_L("Test Purpose: Connect Socket, then Shutdown"));

   482 

   483 	// Connect to esock

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

   485     RSocketServ ss;

   486 	TInt ret = ss.Connect();

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

   488 	TESTL(KErrNone == ret);

   489 	CleanupClosePushL(ss); 

   490 

   491 	// Create and open RConnection

   492 	Logger().WriteFormat(_L("Creating RConnection"));

   493 	RConnection conn; 

   494 	ret = conn.Open(ss);

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

   496 	TESTL(KErrNone == ret);

   497 	CleanupClosePushL(conn);

   498 

   499 	// Create and open socket on TCP protocol

   500 	RSocket socket1;

   501 	

   502 	

   503 	TProtocolDesc protoInfo;

   504 	

   505 	TUint numProtocols;

   506 	ret = ss.NumProtocols(numProtocols);

   507 	Logger().WriteFormat(_L("NumProtocols returned %S, number %d"), 

   508 			&EpocErrorToText(ret), numProtocols);

   509 	TESTL(KErrNone == ret);

   510 

   511 	

   512 	for (TInt index=1;index<=numProtocols;index++) 

   513 		{

   514 		ret = ss.GetProtocolInfo(index, protoInfo);

   515 		Logger().WriteFormat(_L("GetProtocolInfo returned %S"), &EpocErrorToText(ret));	

   516 		TESTL(KErrNone == ret || KErrCannotFindProtocol == ret);

   517 		Logger().WriteFormat(_L("Protocol Index %d corresponds to %S"), index, &protoInfo.iName);

   518 		if (protoInfo.iName == KDummyProtocol1Name())

   519 			{

   520 			break;

   521 			}

   522 		}

   523 	

   524 	

   525 	

   526 	Logger().WriteFormat(_L("Opening Socket 1"));

   527 	ret = socket1.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol /*KAfInet, KSockStream, KProtocolInetTcp, conn*/);

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

   529 	TESTL(KErrNone == ret);

   530 	CleanupClosePushL(socket1); 

   531 

   532 	// Create Ports for Socket and socket to connect to

   533 	const TInt KSocket1Port = 3441;

   534 	const TInt KSocket2Port = 3881;

   535 	_LIT(KLoopback, "127.0.0.1");

   536 	_LIT(KLocal, "0.0.0.0");

   537 

   538 	// Set the local address of Socket1

   539 	TInetAddr socket1Addr;

   540 	socket1Addr.SetPort(KSocket1Port);

   541 	socket1Addr.Input(KLocal);

   542 	ret = socket1.Bind(socket1Addr);

   543 

   544 	// Set remote address for socket 

   545 	TInetAddr socket2Addr;

   546 	socket2Addr.SetPort(KSocket2Port);

   547 	socket2Addr.Input(KLoopback);

   548 

   549 	// Shutdown the Socket

   550 	Logger().WriteFormat(_L("Shutting down Connection on Socket1"));

   551 	TRequestStatus shutdownStatus;

   552 	_LIT8(desOut, "Some test stuff to send to protocol");

   553 	

   554 	TBuf8<50> desIn;

   555 	

   556 	socket1.Shutdown(RSocket::EImmediate,desOut,desIn, shutdownStatus);

   557 	User::WaitForRequest(shutdownStatus);

   558 	Logger().WriteFormat(_L("Socket 1 shutdown returned %S"), &EpocErrorToText(shutdownStatus.Int()));

   559 

   560 	// Connect socket1 to remote address

   561 	TRequestStatus connectSocket1Status;

   562 	Logger().WriteFormat(_L("Connecting Socket1 "));

   563 

   564 	socket1.Connect(socket2Addr, connectSocket1Status);   // used to cause server to panic

   565 	User::WaitForRequest(connectSocket1Status);

   566 

   567 	if(connectSocket1Status != KErrBadHandle)

   568 		{

   569 		verdict = EFail;

   570 		}

   571 	

   572 	CleanupStack::PopAndDestroy(); //socket

   573 	CleanupStack::PopAndDestroy(); //conn

   574 	CleanupStack::PopAndDestroy(); //ss

   575 

   576 	return verdict;

   577 

   578 

   579 	}

   580 

   581 

   582 

   583 

   584