1 /*

     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #include "tsocket.h"

    22 

    23 CTestSocket::~CTestSocket() 

    24 	{ 

    25 	}  

    26 

    27 CTestSocket::CTestSocket(const TDesC& aStepName)

    28 	{

    29 	// MANDATORY Call to base class method to set up the human readable name for logging.

    30 	SetTestStepName(aStepName);		

    31 	}

    32 

    33 TVerdict CTestSocket::doTestStepPreambleL()

    34 	{

    35 	__UHEAP_MARK;	

    36 	SetTestStepResult(EPass);

    37 	return TestStepResult();

    38 	}

    39 

    40 

    41 

    42 TVerdict CTestSocket::doTestStepPostambleL()

    43 	{

    44 	__UHEAP_MARKEND;

    45 	return TestStepResult();

    46 	}

    47 

    48 

    49 TVerdict CTestSocket::doTestStepL()

    50 	{

    51 	int err;

    52 

    53    	if(TestStepName() == KExampleL)

    54    		{

    55 		INFO_PRINTF1(_L("ExampleL():"));

    56 		err = ExampleL();

    57 		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    58 		}

    59 	else

    60 		if(TestStepName() == KUDP)

    61    			{

    62    	   		INFO_PRINTF1(_L("UDP():"));

    63    	   		err = UDP();

    64    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    65    	   		}

    66 	else

    67 		if(TestStepName() == KTCP)

    68    			{

    69    	   		INFO_PRINTF1(_L("TCP():"));

    70    	   		err = TCP();

    71    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    72    	   		}

    73 	else

    74 		if(TestStepName() == KGetSocketName)

    75    			{

    76    	   		INFO_PRINTF1(_L("GetSocketName():"));

    77    	   		err = GetSocketName();

    78    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    79    	   		}

    80 	else

    81 		if(TestStepName() == KGetSocketNameUsingFileDescriptor)

    82    			{

    83    	   		INFO_PRINTF1(_L("GetSocketNameUsingFileDescriptor():"));

    84    	   		err = GetSocketNameUsingFileDescriptor();

    85    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    86    	   		}

    87 	else

    88 		if(TestStepName() == KGetSocketNameUsingInvalidSocketDescriptor)

    89    			{

    90    	   		INFO_PRINTF1(_L("GetSocketNameUsingInvalidSocketDescriptor():"));

    91    	   		err = GetSocketNameUsingInvalidSocketDescriptor();

    92    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    93    	   		}

    94 	else

    95 		if(TestStepName() == KGetSocketNameInvalidLength)

    96    			{

    97    	   		INFO_PRINTF1(_L("GetSocketNameInvalidLength():"));

    98    	   		err = GetSocketNameInvalidLength();

    99    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   100    	   		}

   101 	else

   102 		if(TestStepName() == KGetSocketNameInvalidSocketBuffer)

   103    			{

   104    	   		INFO_PRINTF1(_L("GetSocketNameInvalidSocketBuffer():"));

   105    	   		err = GetSocketNameInvalidSocketBuffer();

   106    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   107    	   		}

   108 	else

   109 		if(TestStepName() == KGetPeerSocketName)

   110    			{

   111    	   		INFO_PRINTF1(_L("GetPeerSocketName():"));

   112    	   		err = GetPeerSocketName();

   113    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   114    	   		}

   115 	else

   116 		if(TestStepName() == KGetPeerSocketNameUsingFileDescriptor)

   117    			{

   118    	   		INFO_PRINTF1(_L("GetPeerSocketNameUsingFileDescriptor():"));

   119    	   		err = GetPeerSocketNameUsingFileDescriptor();

   120    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   121    	   		}

   122 	else

   123 		if(TestStepName() == KGetPeerSocketNameUsingInvalidSocketDescriptor)

   124    			{

   125    	   		INFO_PRINTF1(_L("GetPeerSocketNameUsingInvalidSocketDescriptor():"));

   126    	   		err = GetPeerSocketNameUsingInvalidSocketDescriptor();

   127    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   128    	   		}

   129 	else

   130 		if(TestStepName() == KGetPeerSocketNameforUnconnectedSocket)

   131    			{

   132    	   		INFO_PRINTF1(_L("GetPeerSocketNameforUnconnectedSocket():"));

   133    	   		err = GetPeerSocketNameforUnconnectedSocket();

   134    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   135    	   		}

   136 	else

   137 		if(TestStepName() == KGetPeerSocketNameInvalidLengthSockAddr)

   138    			{

   139    	   		INFO_PRINTF1(_L("GetPeerSocketNameInvalidLengthSockAddr():"));

   140    	   		err = GetPeerSocketNameInvalidLengthSockAddr();

   141    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   142    	   		}

   143 	else

   144 		if(TestStepName() == KBindTest)

   145    			{

   146    	   		INFO_PRINTF1(_L("BindTest():"));

   147    	   		err = BindTest();

   148    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   149    	   		}

   150 	else

   151 		if(TestStepName() == KMultipleBindOnSameSocket)

   152    			{

   153    	   		INFO_PRINTF1(_L("MultipleBindOnSameSocket():"));

   154    	   		err = MultipleBindOnSameSocket();

   155    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   156    	   		}

   157 	else

   158 		if(TestStepName() == KBindInvalidAddress)

   159    			{

   160    	   		INFO_PRINTF1(_L("BindInvalidAddress():"));

   161    	   		err = BindInvalidAddress();

   162    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   163    	   		}

   164 	else

   165 		if(TestStepName() == KBindUsingInvalidSocketDescriptor)

   166    			{

   167    	   		INFO_PRINTF1(_L("BindUsingInvalidSocketDescriptor():"));

   168    	   		err = BindUsingInvalidSocketDescriptor();

   169    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   170    	   		}

   171 	else

   172 		if(TestStepName() == KBindUsingFileDescriptor)

   173    			{

   174    	   		INFO_PRINTF1(_L("BindUsingFileDescriptor():"));

   175    	   		err = BindUsingFileDescriptor();

   176    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   177    	   		}

   178 	else

   179 		if(TestStepName() == KShutdownTest)

   180    			{

   181    	   		INFO_PRINTF1(_L("ShutdownTest():"));

   182    	   		err = ShutdownTest();

   183    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   184    	   		}

   185 	else

   186 		if(TestStepName() == KShutDownTestWithInvalidShutdownOption)

   187    			{

   188    	   		INFO_PRINTF1(_L("ShutDownTestWithInvalidShutdownOption():"));

   189    	   		err = ShutDownTestWithInvalidShutdownOption();

   190    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   191    	   		}

   192 	else

   193 		if(TestStepName() == KShutdownUsingFileDescriptor)

   194    			{

   195    	   		INFO_PRINTF1(_L("ShutdownUsingFileDescriptor():"));

   196    	   		err = ShutdownUsingFileDescriptor();

   197    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   198    	   		}

   199 	else

   200 		if(TestStepName() == KShutdownUsingInvalidSocketDescriptor)

   201    			{

   202    	   		INFO_PRINTF1(_L("ShutdownUsingInvalidSocketDescriptor():"));

   203    	   		err = ShutdownUsingInvalidSocketDescriptor();

   204    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   205    	   		}

   206 	else

   207 		if(TestStepName() == KShutdownDisconnectedSocket)

   208    			{

   209    	   		INFO_PRINTF1(_L("ShutdownDisconnectedSocket():"));

   210    	   		err = ShutdownDisconnectedSocket();

   211    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   212    	   		}

   213 	else

   214 		if(TestStepName() == KSocketTest)

   215    			{

   216    	   		INFO_PRINTF1(_L("SocketTest():"));

   217    	   		err = SocketTest();

   218    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   219    	   		}

   220 	else

   221 		if(TestStepName() == KListenTest)

   222    			{

   223    	   		INFO_PRINTF1(_L("ListenTest():"));

   224    	   		err = ListenTest();

   225    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   226    	   		}

   227 	else

   228 		if(TestStepName() == KListenUsingFileDescriptor)

   229    			{

   230    	   		INFO_PRINTF1(_L("ListenUsingFileDescriptor():"));

   231    	   		err = ListenUsingFileDescriptor();

   232    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   233    	   		}

   234 	else

   235 		if(TestStepName() == KListenUsingInvalidSocketDescriptor)

   236    			{

   237    	   		INFO_PRINTF1(_L("ListenUsingInvalidSocketDescriptor():"));

   238    	   		err = ListenUsingInvalidSocketDescriptor();

   239    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   240    	   		}

   241 	else

   242 		if(TestStepName() == KAcceptTest)

   243    			{

   244    	   		INFO_PRINTF1(_L("AcceptTest():"));

   245    	   		err = AcceptTest();

   246    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   247    	   		}

   248 	else

   249 		if(TestStepName() == KUDPAccept)

   250    			{

   251    	   		INFO_PRINTF1(_L("UDPAccept():"));

   252    	   		err = UDPAccept();

   253    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   254    	   		}

   255 	else

   256 		if(TestStepName() == KAcceptUsingFileDescriptor)

   257    			{

   258    	   		INFO_PRINTF1(_L("AcceptUsingFileDescriptor():"));

   259    	   		err = AcceptUsingFileDescriptor();

   260    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   261    	   		}

   262 	else

   263 		if(TestStepName() == KAcceptUsingInvalidSocketDescriptor)

   264    			{

   265    	   		INFO_PRINTF1(_L("AcceptUsingInvalidSocketDescriptor():"));

   266    	   		err = AcceptUsingInvalidSocketDescriptor();

   267    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   268    	   		}

   269 	else

   270 		if(TestStepName() == KConnectTestFailCases)

   271    			{

   272    	   		INFO_PRINTF1(_L("ConnectTestFailCases():"));

   273    	   		err = ConnectTestFailCases();

   274    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   275    	   		}

   276 	else

   277 		if(TestStepName() == KConnectUsingFileDescriptor)

   278    			{

   279    	   		INFO_PRINTF1(_L("ConnectUsingFileDescriptor():"));

   280    	   		err = ConnectUsingFileDescriptor();

   281    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   282    	   		}

   283 	else

   284 		if(TestStepName() == KConnectUsingInvalidSocketDescriptor)

   285    			{

   286    	   		INFO_PRINTF1(_L("ConnectUsingInvalidSocketDescriptor():"));

   287    	   		err = ConnectUsingInvalidSocketDescriptor();

   288    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   289    	   		}

   290 	else

   291 		if(TestStepName() == KRecvTestFailCases)

   292    			{

   293    	   		INFO_PRINTF1(_L("RecvTestFailCases():"));

   294    	   		err = RecvTestFailCases();

   295    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   296    	   		}

   297 	else

   298 		if(TestStepName() == KRecvUsingInvalidSocketDescriptor)

   299    			{

   300    	   		INFO_PRINTF1(_L("RecvUsingInvalidSocketDescriptor():"));

   301    	   		err = RecvUsingInvalidSocketDescriptor();

   302    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   303    	   		}

   304 	else

   305 		if(TestStepName() == KRecvUsingFileDescriptor)

   306    			{

   307    	   		INFO_PRINTF1(_L("RecvUsingFileDescriptor():"));

   308    	   		err = RecvUsingFileDescriptor();

   309    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   310    	   		}

   311 	else

   312 		if(TestStepName() == KSendTestFailCases)

   313    			{

   314    	   		INFO_PRINTF1(_L("SendTestFailCases():"));

   315    	   		err = SendTestFailCases();

   316    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   317    	   		}

   318 	else

   319 		if(TestStepName() == KSendUsingFileDescriptor)

   320    			{

   321    	   		INFO_PRINTF1(_L("SendUsingFileDescriptor():"));

   322    	   		err = SendUsingFileDescriptor();

   323    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   324    	   		}

   325 	else

   326 		if(TestStepName() == KSendUsingInvalidSocketDescriptor)

   327    			{

   328    	   		INFO_PRINTF1(_L("SendUsingInvalidSocketDescriptor():"));

   329    	   		err = SendUsingInvalidSocketDescriptor();

   330    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   331    	   		}

   332 	else

   333 		if(TestStepName() == KSocketOptions)

   334    			{

   335    	   		INFO_PRINTF1(_L("SocketOptions():"));

   336    	   		err = SocketOptions();

   337    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   338    	   		}

   339 	else

   340 		if(TestStepName() == KGetSockOptFailCases)

   341    			{

   342    	   		INFO_PRINTF1(_L("GetSockOptFailCases():"));

   343    	   		err = GetSockOptFailCases();

   344    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   345    	   		}

   346 	else

   347 		if(TestStepName() == KSetSockOptFailCases)

   348    			{

   349    	   		INFO_PRINTF1(_L("SetSockOptFailCases():"));

   350    	   		err = SetSockOptFailCases();

   351    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   352    	   		}

   353 	else

   354 		if(TestStepName() == KSendToTestFailCases)

   355    			{

   356    	   		INFO_PRINTF1(_L("SendToTestFailCases():"));

   357    	   		err = SendToTestFailCases();

   358    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   359    	   		}

   360 	else

   361 		if(TestStepName() == KSendToUsingFileDescriptor)

   362    			{

   363    	   		INFO_PRINTF1(_L("SendToUsingFileDescriptor():"));

   364    	   		err = SendToUsingFileDescriptor();

   365    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   366    	   		}

   367 	else

   368 		if(TestStepName() == KSendToUsingInvalidSocketDescriptor)

   369    			{

   370    	   		INFO_PRINTF1(_L("SendToUsingInvalidSocketDescriptor():"));

   371    	   		err = SendToUsingInvalidSocketDescriptor();

   372    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   373    	   		}

   374 	else 

   375 		if(TestStepName() == KTestSendReturnValue)

   376 			{

   377 			INFO_PRINTF1(_L("TestSendReturnValue():"));

   378 			err = TestSendReturnValue();

   379 			SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   380 			}                  

   381 	else

   382 		if(TestStepName() == KRecvFromTestFailCases)

   383    			{

   384    	   		INFO_PRINTF1(_L("RecvFromTestFailCases():"));

   385    	   		err = RecvFromTestFailCases();

   386    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   387    	   		}

   388 	else

   389 		if(TestStepName() == KSockAtMark)

   390    			{

   391    	   		INFO_PRINTF1(_L("SockAtMark():"));

   392    	   		err = SockAtMark();

   393    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   394    	   		}

   395 	else

   396 		if(TestStepName() == KBindResvPort)

   397    			{

   398    	   		INFO_PRINTF1(_L("BindResvPort():"));

   399    	   		err = BindResvPort();

   400    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   401    	   		}

   402 	else

   403 		if(TestStepName() == KBindResvPortFailCases)

   404    			{

   405    	   		INFO_PRINTF1(_L("BindResvPortFailCases():"));

   406    	   		err = BindResvPortFailCases();

   407    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   408    	   		}

   409 	else

   410 		if(TestStepName() == KHErrNoLocation)

   411    			{

   412    	   		INFO_PRINTF1(_L("HErrNoLocation():"));

   413    	   		err = HErrNoLocation();

   414    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   415    	   		}

   416 	else

   417 		if(TestStepName() == KSendMsgRecvMsg)

   418    			{

   419    	   		INFO_PRINTF1(_L("SendMsgRecvMsg():"));

   420    	   		err = SendMsgRecvMsg();

   421    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   422    	   		}

   423 	else

   424 		if(TestStepName() == KTestRecv)

   425    			{

   426    	   		INFO_PRINTF1(_L("TestRecv():"));

   427    	   		err = TestRecv();

   428    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   429    	   		}

   430 	else

   431 		if(TestStepName() == KTestReadStream)

   432    			{

   433    	   		INFO_PRINTF1(_L("TestReadStream():"));

   434    	   		err = TestReadStream();

   435    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   436    	   		}

   437 	else

   438 		if(TestStepName() == KTestReadDatagram)

   439    			{

   440    	   		INFO_PRINTF1(_L("TestReadDatagram():"));

   441    	   		err = TestReadDatagram();

   442    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   443    	   		}

   444 	else

   445 		if(TestStepName() == KBindFailCases)

   446    			{

   447    	   		INFO_PRINTF1(_L("BindFailCases():"));

   448    	   		err = BindFailCases();

   449    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   450    	   		}

   451 	else

   452    	   	if(TestStepName() == KAcceptFailCases)

   453    			{

   454    	   		INFO_PRINTF1(_L("AcceptFailCases():"));

   455    	   		err = AcceptFailCases();

   456    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   457    	   		}

   458    	else

   459    	   if(TestStepName() == KAcceptTestZeroAddrLen)

   460    	    	{

   461    	      		INFO_PRINTF1(_L("AcceptTestZeroAddrLen():"));

   462    	       		err = AcceptTestZeroAddrLen();

   463    	       		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   464    	    	}

   465 	else

   466 	   if(TestStepName() == KAcceptTestNullAddr)

   467 	    	{

   468 	      		INFO_PRINTF1(_L("AcceptTestNullAddr():"));

   469 	       		err = AcceptTestNullAddr();

   470 	       		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   471 	    	}

   472 	 else

   473 		if(TestStepName() == KListenUdp)

   474    			{

   475    	   		INFO_PRINTF1(_L("ListenUdp():"));

   476    	   		err = ListenUdp();

   477    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   478    	   		}

   479 	else

   480 		if(TestStepName() == KGetHostName)

   481    			{

   482    	   		INFO_PRINTF1(_L("GetHostName():"));

   483    	   		err = GetHostName();

   484    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   485    	   		}

   486 	else

   487 		if(TestStepName() == KGetHostNameNull)

   488    			{

   489    	   		INFO_PRINTF1(_L("GetHostNameNull():"));

   490    	   		err = GetHostNameNull();

   491    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   492    	   		}

   493 	else

   494 		if(TestStepName() == KGetHostNameZero)

   495    			{

   496    	   		INFO_PRINTF1(_L("GetHostNameZero():"));

   497    	   		err = GetHostNameZero();

   498    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   499    	   		}

   500    	else

   501 		if(TestStepName() == KTestSktlseek)

   502    			{

   503    	   		INFO_PRINTF1(_L("TestSktlseek():"));

   504    	   		err = TestSktlseek();

   505    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   506    	   		}

   507    	else

   508 		if(TestStepName() == KTestSockAfLocal)

   509    			{

   510    	   		INFO_PRINTF1(_L("TestSockAfLocal():"));

   511    	   		err = TestSockAfLocal();

   512    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   513    	   		}

   514 	else

   515 		if(TestStepName() == KTestSktfstat)

   516    			{

   517    	   		INFO_PRINTF1(_L("TestSktfstat():"));

   518    	   		err = TestSktfstat();

   519    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   520    	   		}

   521    	else

   522 		if(TestStepName() == KTestSktfsync)

   523    			{

   524    	   		INFO_PRINTF1(_L("TestSktfsync():"));

   525    	   		err = TestSktfsync();

   526    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   527    	   		}

   528    	else

   529 		if(TestStepName() == KTestGreaterThan16kReadWrite)

   530    			{

   531    	   		INFO_PRINTF1(_L("TestGreaterThan16kReadWrite():"));

   532    	   		err = TestGreaterThan16kReadWrite();

   533    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   534    	   		}

   535 		else

   536 			if(TestStepName() == KTestNotify)

   537 		   		{

   538 		   		INFO_PRINTF1(_L("TestNotify():"));

   539 		   		err = TestNotify();

   540 		   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   541 		   		} 

   542 	else

   543 		if(TestStepName() == KTestRecvMsgPeekTCP)

   544 	   		{

   545 	   		INFO_PRINTF1(_L("TestRecvMsgPeekTCP():"));

   546 	   		err = TestRecvMsgPeekTCP();

   547 	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   548 	   		} 

   549 	else

   550 		if(TestStepName() == KTestRecvMsgPeekUDP)

   551 	   		{

   552 	   		INFO_PRINTF1(_L("TestRecvMsgPeekUDP():"));

   553 	   		err = TestRecvMsgPeekUDP();

   554 	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   555 	   		} 

   556 	else

   557 		if(TestStepName() == KTestLargeUDP)

   558 		{

   559 		INFO_PRINTF1(_L("TestLargeUDP:"));

   560 		err = TestLargeUDP();

   561 		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   562 		}

   563 	else

   564 		if(TestStepName() == KTestFionread)

   565    			{

   566    	   		INFO_PRINTF1(_L("TestFionread():"));

   567    	   		err = TestFionread();

   568    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   569    	   		}	

   570 	else

   571 		if(TestStepName() == KTestBind1)

   572 	   		{

   573 	   		INFO_PRINTF1(_L("TestBind1():"));

   574 	   		err = TestBind1();

   575 	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   576 	   		}		

   577 	else

   578 		if(TestStepName() == KTestConnectNonBlocking)

   579 	   		{

   580 	   		INFO_PRINTF1(_L("TestConnectNonBlocking():"));

   581 	   		err = TestConnectNonBlocking();

   582 	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   583 	   		}		

   584 	else

   585 		if(TestStepName() == KTCP1)

   586    			{

   587    	   		INFO_PRINTF1(_L("TCP1():"));

   588    	   		err = TCP1();

   589    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   590    	   		}

   591 	else

   592 		if(TestStepName() == KTestV4MappedAddress)

   593    			{

   594    	   		INFO_PRINTF1(_L("TestV4MappedAddress():"));

   595    	   		err = TestV4MappedAddress();

   596    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   597    	   		}	

   598    	else

   599 		if(TestStepName() == KReadTestFailCase)

   600    			{

   601    	   		INFO_PRINTF1(_L("ReadTestFailCase():"));

   602    	   		err = ReadTestFailCase();

   603    	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   604    	   		}

   605 	else

   606 		if(TestStepName() == KTestNotify1)

   607 			{

   608 			INFO_PRINTF1(_L("TestNotify1():"));

   609 			err = TestNotify1();

   610 			SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   611 			}

   612 	else

   613 		if(TestStepName() == KTestSockFcntl)

   614 			{

   615 			INFO_PRINTF1(_L("TestSockFcntl():"));

   616 			err = TestSockFcntl();

   617 			SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   618 			}

   619 	else

   620 		if(TestStepName() == KTestSockIoctl)

   621 			{

   622 			INFO_PRINTF1(_L("TestSockIoctl():"));

   623 			err = TestSockIoctl();

   624 			SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   625 			}

   626 	else

   627 		if(TestStepName() == KSockErrnoTest)

   628 			{

   629 			INFO_PRINTF1(_L("SockErrnoTest():"));

   630 			err = SockErrnoTest();

   631 			SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   632 			}

   633     else

   634         if(TestStepName() == KSockSendOnClosedConn )

   635             {

   636             INFO_PRINTF1(_L("SockSendOnClosedConn():"));

   637             err = SockSendOnClosedConn();

   638             SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   639             }

   640    	

   641 return TestStepResult(); 

   642 

   643 	}

   644  

   645