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 14

    15 // 

    16 //

    17 

    18 // EPOC includes

    19 #include <e32base.h>

    20 #include <test/es_dummy.h>

    21 

    22 // Test system includes

    23 #include "SocketTestSection14.h"

    24 

    25 

    26 // Test step 14.1

    27 const TDesC& CSocketTest14_1::GetTestName()

    28 	{

    29 	_LIT(ret,"Test14.1");

    30 	return ret;

    31 	}

    32 

    33 enum TVerdict CSocketTest14_1::InternalDoTestStepL( void )

    34 	{

    35 	TVerdict verdict = EPass;

    36 	

    37 	Logger().WriteFormat(_L("Testing erroring a listening socket"));

    38 	RSocketServ ss;

    39 	TInt ret=OptimalConnect(ss);

    40 	CleanupClosePushL(ss);

    41     TESTL(KErrNone == ret);	

    42     

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

    44 	RSocket sock, sock2;                                                    

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

    46 	TESTL(KErrNone == ret);	

    47 	

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

    49 	TESTL(KErrNone == ret);	

    50 	

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

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

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

    54 	TESTL(KErrNone == ret);	

    55 	

    56 	TSockAddr addr;

    57 	ret=sock.Bind(addr);

    58 	TESTL(KErrNone == ret);	

    59 	

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

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

    62 	TESTL(KErrNone == ret);	

    63 	

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

    65 	TRequestStatus rstat;

    66 	sock.Accept(sock2, rstat);

    67 	User::WaitForRequest(rstat);

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

    69 	

    70 	Logger().WriteFormat(_L("Listen - reconnect"));             

    71 	ret=sock.Listen(1);

    72 	TESTL(KErrNone == ret);	

    73 	

    74     Logger().WriteFormat(_L("Accept"));             

    75 	sock.Accept(sock2, rstat);

    76     //emulate en connect complete event

    77 	ret=sock.SetOpt(KDummyOptionSetConnectComplete,0,0);

    78 	TESTL(KErrNone == ret);	

    79 	User::WaitForRequest(rstat);

    80 	TESTL(rstat.Int() == KErrNone);	

    81 	

    82 	CleanupStack::Pop(&ss);

    83     ss.Close();

    84 	

    85 	SetTestStepResult(verdict);

    86 	return verdict;

    87 	}

    88 	

    89 	// Test step 14.2

    90 const TDesC& CSocketTest14_2::GetTestName()

    91 	{

    92 	_LIT(ret,"Test14.2");

    93 	return ret;

    94 	}

    95 

    96 enum TVerdict CSocketTest14_2::InternalDoTestStepL( void )

    97 	{

    98 	TVerdict verdict = EPass;

    99 	TInt ret;

   100 	

   101 	Logger().WriteFormat(_L("Test14.2 Error writing to socket"));

   102 	RSocketServ ss;

   103 	ret = OptimalConnect(ss);

   104 	TESTL(KErrNone == ret);	

   105 	CleanupClosePushL(ss);

   106     

   107 	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             

   108 	RSocket sock;                                                  

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

   110 	TESTL(KErrNone == ret);

   111 	

   112 	TSockAddr addr;

   113 	TRequestStatus stat;

   114 	sock.Connect(addr, stat);

   115 	User::WaitForRequest(stat);

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

   117 	

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

   119 	Logger().WriteFormat(_L("Set write error code to %d"), KExpectedError);             

   120 	ret=sock.SetOpt(KDummyOptionSetErrorNextWrite, 0, KExpectedError);

   121 	TESTL(KErrNone == ret);	

   122 		

   123 	_LIT8(KWriteData,"1234\t\n\rcwe8\'\"");

   124 	Logger().WriteFormat(_L("Sending Data - Should fail with %d"), KExpectedError);             

   125 	sock.Send(KWriteData(), 0, stat);

   126 	User::WaitForRequest(stat);

   127 	TESTL(KExpectedError == stat.Int());	

   128 	

   129 	Logger().WriteFormat(_L("Sending Data - Should Succeed"));             

   130 	sock.Send(KWriteData(),0,stat);

   131 	User::WaitForRequest(stat);

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

   133 	

   134 	Logger().WriteFormat(_L("Receiving Data"));

   135 	TBuf8<20> buf;          

   136 	sock.Recv(buf, 0, stat);

   137 	User::WaitForRequest(stat);

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

   139 	

   140     TESTL(buf == KWriteData);	

   141 	

   142 	CleanupStack::Pop(&ss);

   143     ss.Close();

   144 	

   145 	SetTestStepResult(verdict);

   146 	return verdict;

   147 	}

   148 	

   149 	// Test step 14.3

   150 const TDesC& CSocketTest14_3::GetTestName()

   151 	{

   152 	_LIT(ret,"Test14.3");

   153 	return ret;

   154 	}

   155 

   156 enum TVerdict CSocketTest14_3::InternalDoTestStepL( void )

   157 	{

   158 	TVerdict verdict = EPass;

   159 	TInt ret;

   160 	

   161 	Logger().WriteFormat(_L("Test14.3 Error shutting a socket down"));

   162 	RSocketServ ss;

   163 	ret = OptimalConnect(ss);

   164 	TESTL(KErrNone == ret);	

   165 	CleanupClosePushL(ss);

   166     

   167 	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             

   168 	RSocket sock;                                                  

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

   170 	TESTL(KErrNone == ret);

   171 	

   172 	TSockAddr addr;

   173 	TRequestStatus stat;

   174 	sock.Connect(addr, stat);

   175 	User::WaitForRequest(stat);

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

   177 	

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

   179 	Logger().WriteFormat(_L("Set write error code to %d"), KExpectedError);             

   180 	ret=sock.SetOpt(KDummyOptionSetErrorNextShutdown, 0, KExpectedError);

   181 	TESTL(KErrNone == ret);	

   182 	

   183 	Logger().WriteFormat(_L("Shutting the socket down"));             

   184 	sock.Shutdown(RSocket::EImmediate,stat);

   185 	User::WaitForRequest(stat);

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

   187 	

   188 	CleanupStack::Pop(&ss);

   189     ss.Close();

   190 	

   191 	SetTestStepResult(verdict);

   192 	return verdict;

   193 	}

   194 	

   195 		// Test step 14.4

   196 const TDesC& CSocketTest14_4::GetTestName()

   197 	{

   198 	_LIT(ret,"Test14.4");

   199 	return ret;

   200 	}

   201 

   202 enum TVerdict CSocketTest14_4::InternalDoTestStepL( void )

   203 	{

   204 	TVerdict verdict = EPass;

   205 	TInt ret;

   206 	

   207 	Logger().WriteFormat(_L("Test14.4 Error connecting to socket down"));

   208 	RSocketServ ss;

   209 	ret = OptimalConnect(ss);

   210 	TESTL(KErrNone == ret);	

   211 	CleanupClosePushL(ss);

   212     

   213 	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             

   214 	RSocket sock;                                                  

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

   216 	TESTL(KErrNone == ret);

   217 	

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

   219 	Logger().WriteFormat(_L("Set connect error code to %d"), KExpectedError);             

   220 	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);

   221 	TESTL(KErrNone == ret);

   222 	

   223 	TSockAddr addr;

   224 	TRequestStatus stat;

   225 	sock.Connect(addr, stat);

   226 	User::WaitForRequest(stat);

   227 	TESTL(KExpectedError == stat.Int());

   228 	

   229 	Logger().WriteFormat(_L("Set write error code to %d"), KExpectedError);             

   230 	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);

   231 	TESTL(KErrNone == ret);

   232 	

   233 	Logger().WriteFormat(_L("Performing Connect"));

   234 	sock.Connect(addr, stat);

   235 	User::WaitForRequest(stat);

   236 	TESTL(KExpectedError == stat.Int());	

   237 	

   238 	Logger().WriteFormat(_L("Setting blocked connect"));             

   239 	ret=sock.SetOpt(KDummyOptionSetBlockConnect, 0, TRUE);

   240 	TESTL(KErrNone == ret);

   241 	

   242 	Logger().WriteFormat(_L("Set connect error code to %d"), KExpectedError);             

   243 	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);

   244 	TESTL(KErrNone == ret);	

   245 	

   246 	Logger().WriteFormat(_L("Performing Connect"));

   247 	sock.Connect(addr, stat);

   248 	User::WaitForRequest(stat);

   249 	TESTL(KExpectedError == stat.Int());		

   250 	

   251 	Logger().WriteFormat(_L("Setting blocked connect"));             

   252 	ret=sock.SetOpt(KDummyOptionSetBlockConnect, 0, TRUE);

   253 	TESTL(KErrNone == ret);

   254 	

   255 	Logger().WriteFormat(_L("Performing Connect"));

   256 	sock.Connect(addr, stat);

   257 	

   258 	Logger().WriteFormat(_L("Set connect error code to %d"), KExpectedError);             

   259 	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);

   260 	TESTL(KErrNone == ret);	

   261 	

   262 	Logger().WriteFormat(_L("Setting blocked connect off"));             

   263 	ret=sock.SetOpt(KDummyOptionSetBlockConnect, 0, FALSE);

   264 	TESTL(KErrNone == ret);

   265 		

   266 	User::WaitForRequest(stat);

   267 	TESTL(KExpectedError == stat.Int());	

   268 	

   269 	

   270 	CleanupStack::Pop(&ss);

   271     ss.Close();

   272 	

   273 	SetTestStepResult(verdict);

   274 	return verdict;

   275 	}

   276 	

   277 		// Test step 14.5

   278 const TDesC& CSocketTest14_5::GetTestName()

   279 	{

   280 	_LIT(ret,"Test14.5");

   281 	return ret;

   282 	}

   283 

   284 enum TVerdict CSocketTest14_5::InternalDoTestStepL( void )

   285 	{

   286 	TVerdict verdict = EPass;

   287 	TInt ret;

   288 	

   289 	Logger().WriteFormat(_L("Test14.5 Two accepts accepting on the same null socket"));

   290 	RSocketServ ss;

   291 	ret = OptimalConnect(ss);

   292 	TESTL(KErrNone == ret);	

   293 	CleanupClosePushL(ss);

   294     

   295 	Logger().WriteFormat(_L("Openning Dummy Protocol 2"));             

   296 	RSocket sock;                                                  

   297 	ret = sock.Open(ss,_L("Dummy Protocol 2")); 

   298 	TESTL(KErrNone == ret);

   299 	

   300 	TSockAddr addr;

   301 	TRequestStatus stat;

   302 	

   303 	Logger().WriteFormat(_L("Binding sock1"));             

   304 	ret = sock.Bind(addr); 

   305 	TESTL(KErrNone == ret);

   306 	

   307 	Logger().WriteFormat(_L("Listening on sock1"));             

   308 	ret = sock.Listen(5); 

   309 	TESTL(KErrNone == ret);

   310 	

   311 	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             

   312 	RSocket sock2;                                                  

   313 	ret = sock2.Open(ss,_L("Dummy Protocol 3")); 

   314 	TESTL(KErrNone == ret);

   315 	

   316 	TSockAddr addr2;

   317 		

   318 	Logger().WriteFormat(_L("Binding sock2"));             

   319 	ret = sock2.Bind(addr); 

   320 	TESTL(KErrNone == ret);

   321 	

   322 	Logger().WriteFormat(_L("Listening on sock2"));             

   323 	ret = sock2.Listen(5); 

   324 	TESTL(KErrNone == ret);

   325 	

   326 	Logger().WriteFormat(_L("Null socket"));             

   327 	RSocket nullsock;                                                  

   328 	ret = nullsock.Open(ss); 

   329 	TESTL(KErrNone == ret);

   330 	

   331 	TRequestStatus stat2;

   332 	

   333 	Logger().WriteFormat(_L("Accepting on sock1"));             

   334 	sock.Accept(nullsock,stat); 

   335 	

   336 	Logger().WriteFormat(_L("Accepting on sock2"));             

   337 	sock2.Accept(nullsock,stat2); 

   338 	

   339 	// Wait to be paniced

   340 	User::After( 5000000 );

   341 	

   342 	//Should have panicked by now so lets just fail the test.

   343 	verdict = EFail;

   344 	CleanupStack::Pop(&ss);

   345     ss.Close();

   346 	

   347 	SetTestStepResult(verdict);

   348 	return verdict;

   349 	}

   350 

   351 

   352 

   353