1 // Copyright (c) 2005-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 #if !defined(PTESTCASES_H)

    17 #define PTESTCASES_H

    18 

    19 #include <e32base.h>

    20 #include <test/testexecutestepbase.h>

    21 #include "proxyprotocol.h"

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

    23 #include <es_mbuf.h>

    24 #include "agregate.h"

    25 

    26 NONSHARABLE_CLASS(CEIntSockTestBase) : protected CActive, public MTestStepNotify

    27 	{

    28 	public:

    29 		static void StartTestL(const TDesC& aTestName, CProxyProvd* aProvd);

    30 		virtual void RunL();

    31 		virtual void AboutToShutdown();

    32 	

    33 	protected:		

    34 		CEIntSockTestBase(CProxyProvd* aProvd);

    35 		virtual ~CEIntSockTestBase();

    36 		

    37 		//Utilities function to be use in RunTest()

    38 		void Reschedule();

    39 		CTestExecuteLogger iLogger;

    40 						

    41 	private:

    42 		//Implemented you own of these		

    43 		virtual TVerdict RunTestL() = 0;

    44 		virtual void Cleanup();

    45 		

    46 		void DoCancel();

    47 		void ConstructL();

    48 		void SetLoggerL();

    49 		CTestExecuteLogger& Logger();

    50 		void FinishTest(TVerdict result);

    51 		static CEIntSockTestBase* CreateTestL(const TDesC& aTestName, CProxyProvd* aProvd);

    52 		

    53 	private:

    54 		CProxyProvd* iProvd;

    55 		TBool iReschedule; //Determines whether rescheduling is required

    56 	};

    57 	

    58 inline CTestExecuteLogger& CEIntSockTestBase::Logger()

    59 {

    60 	return iLogger;

    61 }

    62 

    63 

    64 NONSHARABLE_CLASS(CEIntSockTest1) : public CEIntSockTestBase

    65 	{

    66 	public:

    67 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

    68 		

    69 	private:

    70 		CEIntSockTest1(CProxyProvd* aProvd);

    71 		virtual TVerdict RunTestL();

    72 		void Cleanup();

    73 		RInternalSocket iSocket;

    74 	};

    75 	

    76 NONSHARABLE_CLASS(CEIntSockTest2) : public CEIntSockTestBase

    77 	{

    78 	public:

    79 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

    80 		

    81 	private:

    82 		CEIntSockTest2(CProxyProvd* aProvd);

    83 		virtual TVerdict RunTestL();

    84 		void Cleanup();

    85 		RInternalSocket iSocket;

    86 	};

    87 	

    88 NONSHARABLE_CLASS(CEIntSockTest3) : public CEIntSockTestBase

    89 	{

    90 	public:

    91 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

    92 		

    93 	private:

    94 		CEIntSockTest3(CProxyProvd* aProvd);

    95 		virtual TVerdict RunTestL();

    96 		void Cleanup();

    97 		RInternalSocket iSocket;

    98 	};

    99 	

   100 NONSHARABLE_CLASS(CEIntSockTest4) : public CEIntSockTestBase

   101 	{

   102 	public:

   103 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   104 		

   105 	private:

   106 		CEIntSockTest4(CProxyProvd* aProvd);

   107 		virtual TVerdict RunTestL();

   108 		void Cleanup();

   109 		RInternalSocket iSocket;

   110 	};

   111 	

   112 NONSHARABLE_CLASS(CEIntSockTest5) : public CEIntSockTestBase

   113 	{

   114 	public:

   115 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   116 		

   117 	private:

   118 		enum TState {EState1,EState2,EState3,EState4};

   119 		CEIntSockTest5(CProxyProvd* aProvd);

   120 		virtual TVerdict RunTestL();

   121 		void Cleanup();

   122 		RInternalSocket iSocket;

   123 		TState iState;

   124 		TBuf8<20> iBuf;

   125 		TInetAddr iAddress;

   126 		TPtr8 iRecvBufPtr;

   127 	};

   128 	

   129 NONSHARABLE_CLASS(CEIntSockTest6) : public CEIntSockTestBase

   130 	{

   131 	public:

   132 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   133 		

   134 	private:

   135 		enum TState {EState1,EState2,EState3,EState4};

   136 		CEIntSockTest6(CProxyProvd* aProvd);

   137 		virtual TVerdict RunTestL();

   138 		void Cleanup();

   139 		RInternalSocket iSocket;

   140 		TState iState;

   141 		TBuf8<20> iBuf;

   142 		TInetAddr iAddress;

   143 	};

   144 	

   145 NONSHARABLE_CLASS(CEIntSockTest7) : public CEIntSockTestBase

   146 	{

   147 	public:

   148 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   149 		

   150 	private:

   151 		enum TState {EState1,EState2,EState3,EState4};

   152 		CEIntSockTest7(CProxyProvd* aProvd);

   153 		virtual TVerdict RunTestL();

   154 		void Cleanup();

   155 		RInternalSocket iSocket;

   156 		TState iState;

   157 		TBuf8<20> iBuf;

   158 		RMBufChain iSendChain;

   159 		RMBufChain iRecvChain;

   160 		TInetAddr iAddress;

   161 	};

   162 	

   163 NONSHARABLE_CLASS(CEIntSockTest8) : public CEIntSockTestBase

   164 	{

   165 	public:

   166 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   167 		

   168 	private:

   169 		enum TState {EState1,EState2,EState3,EState4};

   170 		CEIntSockTest8(CProxyProvd* aProvd);

   171 		virtual TVerdict RunTestL();

   172 		void Cleanup();

   173 		RInternalSocket iSocket;

   174 		TState iState;

   175 		TBuf8<20> iBuf;

   176 		RMBufChain iSendChain;

   177 		RMBufChain iRecvChain;

   178 		TInetAddr iAddress;		

   179 	};

   180 	

   181 NONSHARABLE_CLASS(CEIntSockTest9) : public CEIntSockTestBase

   182 	{

   183 	public:

   184 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   185 		

   186 	private:

   187 		CEIntSockTest9(CProxyProvd* aProvd);

   188 		virtual TVerdict RunTestL();

   189 		void Cleanup();

   190 		RInternalSocket iSocket;

   191 	};

   192 	

   193 NONSHARABLE_CLASS(CEIntSockTest10) : public CEIntSockTestBase

   194 	{

   195 	public:

   196 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   197 		

   198 	private:

   199 		enum TState {EState1,EState2};

   200 		CEIntSockTest10(CProxyProvd* aProvd);

   201 		virtual TVerdict RunTestL();

   202 		void Cleanup();

   203 		RInternalSocket iSocket;

   204 		TState iState;

   205 	};

   206 	

   207 NONSHARABLE_CLASS(CEIntSockTest11) : public CEIntSockTestBase

   208 	{

   209 	public:

   210 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   211 		

   212 	private:

   213 		enum TState {EState1,EState2,EState3};

   214 		CEIntSockTest11(CProxyProvd* aProvd);

   215 		virtual TVerdict RunTestL();

   216 		void Cleanup();

   217 		RInternalSocket iSocket;

   218 		TState iState;

   219 	};		

   220 	

   221 NONSHARABLE_CLASS(CEIntSockTest12) : public CEIntSockTestBase

   222 	{

   223 	public:

   224 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   225 		

   226 	private:

   227 		enum TState {EState1,EState2,EState3};

   228 		CEIntSockTest12(CProxyProvd* aProvd);

   229 		virtual TVerdict RunTestL();

   230 		void Cleanup();

   231 		RInternalSocket iSocket;

   232 		RInternalSocket iNewSock;

   233 		TState iState;

   234 		TInetAddr iAddress;

   235 	};	

   236 	

   237 NONSHARABLE_CLASS(CEIntSockTest13) : public CEIntSockTestBase

   238 	{

   239 	public:

   240 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   241 		

   242 	private:

   243 		enum TState {EState1,EState2,EState3};

   244 		CEIntSockTest13(CProxyProvd* aProvd);

   245 		virtual TVerdict RunTestL();

   246 		void Cleanup();

   247 		RInternalSocket iSocket;

   248 		TState iState;

   249 		TInetAddr iAddress;

   250 	};

   251 	

   252 NONSHARABLE_CLASS(CEIntSockTest14) : public CEIntSockTestBase

   253 	{

   254 	public:

   255 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   256 		~CEIntSockTest14();

   257 		

   258 	private:

   259 		enum TState {EState1,EState2,EState3,EState4,EState5,EState6};

   260 		CEIntSockTest14(CProxyProvd* aProvd);

   261 		void ConstructL();

   262 		virtual TVerdict RunTestL();

   263 		void Cleanup();

   264 		RInternalSocket iSocket;

   265 		RInternalSocket iNewSock;

   266 		TBuf8<20> iBuf;

   267 		CAggregateCollection* iColl;

   268 		CAggregateItem* iSendItem;

   269 		CAggregateItem* iIoctlItem;

   270 		CAggregateItem* iConnectItem;		

   271 		TState iState;

   272 		TInetAddr		iAddress;

   273 	};		

   274 	

   275 NONSHARABLE_CLASS(CEIntSockTest15) : public CEIntSockTestBase

   276 	{

   277 	public:

   278 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   279 		

   280 	private:

   281 		enum TState {EState1,EState2,EState3};

   282 		CEIntSockTest15(CProxyProvd* aProvd);

   283 		virtual TVerdict RunTestL();

   284 		void Cleanup();

   285 		RInternalSocket iSocket;

   286 		TBuf8<20> iBuf;

   287 		TState iState;

   288 		TInetAddr iAddress;

   289 	};

   290 	

   291 NONSHARABLE_CLASS(CEIntSockTest16) : public CEIntSockTestBase

   292 	{

   293 	public:

   294 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   295 		

   296 	private:

   297 		enum TState {EState1,EState2,EState3};

   298 		CEIntSockTest16(CProxyProvd* aProvd);

   299 		virtual TVerdict RunTestL();

   300 		void Cleanup();

   301 		RInternalSocket iSocket;

   302 		TBuf8<20> iBuf;

   303 		TState iState;

   304 		TInetAddr iAddress;		

   305 	};

   306 	

   307 NONSHARABLE_CLASS(CEIntSockTest17) : public CEIntSockTestBase

   308 	{

   309 	public:

   310 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   311 		

   312 	private:

   313 		enum TState {EState1,EState2,EState3,EState4,EState5};

   314 		CEIntSockTest17(CProxyProvd* aProvd);

   315 		~CEIntSockTest17();

   316 		void ConstructL();

   317 		virtual TVerdict RunTestL();

   318 		void Cleanup();

   319 		RInternalSocket iSocket;

   320 		TBuf8<20> iBuf;

   321 		CAggregateCollection* iColl;

   322 		CAggregateItem* iSendItem;

   323 		CAggregateItem* iRecvItem;

   324 		TState iState;

   325 		TInetAddr iAddress;		

   326 	};

   327 

   328 const TInt KTest18NumSockets = 3;

   329 NONSHARABLE_CLASS(CEIntSockTest18) : public CEIntSockTestBase

   330 	{

   331 	public:

   332 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   333 		

   334 	private:

   335 		CEIntSockTest18(CProxyProvd* aProvd);

   336 		virtual TVerdict RunTestL();

   337 		void Cleanup();

   338 		RInternalSocket iSockets[KTest18NumSockets];

   339 	};	

   340 	

   341 const TInt KTest19NumSockets = 3;

   342 NONSHARABLE_CLASS(CEIntSockTest19) : public CEIntSockTestBase

   343 	{

   344 	public:

   345 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   346 		

   347 	private:

   348 		CEIntSockTest19(CProxyProvd* aProvd);

   349 		virtual TVerdict RunTestL();

   350 		void Cleanup();

   351 		RInternalSocket iSockets[KTest19NumSockets];

   352 	};	

   353 

   354 const TInt KTest20NumCloses = 3;

   355 NONSHARABLE_CLASS(CEIntSockTest20) : public CEIntSockTestBase

   356 	{

   357 	public:

   358 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   359 		

   360 	private:

   361 		CEIntSockTest20(CProxyProvd* aProvd);

   362 		virtual TVerdict RunTestL();

   363 		void Cleanup();

   364 		RInternalSocket iSocket;

   365 	};

   366 	

   367 NONSHARABLE_CLASS(CEIntSockTest21) : public CEIntSockTestBase

   368 	{

   369 	public:

   370 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   371 		

   372 	private:

   373 		CEIntSockTest21(CProxyProvd* aProvd);

   374 		virtual TVerdict RunTestL();

   375 		void Cleanup();

   376 		RInternalSocket iSocket;

   377 	};

   378 	

   379 NONSHARABLE_CLASS(CEIntSockTest22) : public CEIntSockTestBase

   380 	{

   381 	public:

   382 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   383 		

   384 	private:

   385 		CEIntSockTest22(CProxyProvd* aProvd);

   386 		virtual TVerdict RunTestL();

   387 		void Cleanup();

   388 		RInternalSocket iSocket;

   389 	};

   390 	

   391 NONSHARABLE_CLASS(CEIntSockTest23) : public CEIntSockTestBase

   392 	{

   393 	public:

   394 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   395 		

   396 	private:

   397 		enum TState {EState1,EState2};

   398 		CEIntSockTest23(CProxyProvd* aProvd);

   399 		virtual TVerdict RunTestL();

   400 		void Cleanup();

   401 		RInternalSocket iSocket;

   402 		TState iState;

   403 		TBuf8<20> iOut;

   404 		TBuf8<20> iIn;

   405 		TInetAddr iAddress;

   406 	};

   407 

   408 NONSHARABLE_CLASS(CEIntSockTest25A) : public CEIntSockTestBase

   409 	{

   410 	public:

   411 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   412 		

   413 	private:

   414 		~CEIntSockTest25A();

   415 		CEIntSockTest25A(CProxyProvd* aProvd);

   416 		void ConstructL();

   417 		virtual TVerdict RunTestL();

   418 		void Cleanup();

   419 

   420 		enum TState {EState1,EState2};

   421 		TState iState;

   422 

   423 		// the socket on which the operations in this test will happen

   424 		RInternalSocket iSocket;

   425 		

   426 		CAggregateCollection* iColl;

   427 		CAggregateItem* iConnectItem;

   428 		CAggregateItem* iIoctlItem;

   429 		TInetAddr iAddress;		

   430 	};

   431 

   432 NONSHARABLE_CLASS(CEIntSockTest25B) : public CEIntSockTestBase

   433 	{

   434 	public:

   435 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   436 				

   437 	private:

   438 		~CEIntSockTest25B();

   439 		CEIntSockTest25B(CProxyProvd* aProvd);

   440 		void ConstructL();

   441 		virtual TVerdict RunTestL();

   442 		void Cleanup();

   443 		

   444 

   445 		enum TState {EState1,EState2};

   446 		TState iState;

   447 

   448 		// the socket on which the operations in this test will happen

   449 		RInternalSocket iSocket;

   450 		RInternalSocket iNewSock;

   451 		

   452 		CAggregateCollection* iColl;

   453 		CAggregateItem* iAcceptItem;

   454 		CAggregateItem* iIoctlItem;

   455 	};

   456 	

   457 NONSHARABLE_CLASS(CEIntSockTest25C) : public CEIntSockTestBase

   458 	{

   459 	public:

   460 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   461 		

   462 	private:

   463 		void ConstructL();

   464 		~CEIntSockTest25C();

   465 		CEIntSockTest25C(CProxyProvd* aProvd);

   466 		virtual TVerdict RunTestL();

   467 		void Cleanup();

   468 		

   469 		enum TState {EState1,EState2,EState3};

   470 		TState iState;

   471 

   472 		// the socket on which the operations in this test will happen

   473 		RInternalSocket iSocket;

   474 		TBuf8<20> iRecvBuf;

   475 

   476 		CAggregateCollection* iColl;

   477 		CAggregateItem* iRecvItem;

   478 		CAggregateItem* iIoctlItem;

   479 		TInetAddr iAddress;		

   480 	};

   481 	

   482 NONSHARABLE_CLASS(CEIntSockTest26) : public CEIntSockTestBase

   483 	{

   484 	public:

   485 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   486 		

   487 	private:

   488 		CEIntSockTest26(CProxyProvd* aProvd);

   489 		virtual TVerdict RunTestL();

   490 		void Cleanup();

   491 		

   492 		enum TState {EState1,EState2,EState3,EState4,EState5};

   493 		TState iState;

   494 

   495 		// the socket on which the operations in this test will happen

   496 		RInternalSocket iSocket;

   497 		TBuf8<20> iBuf;

   498 		TInetAddr iAddress;		

   499 	};

   500 

   501 NONSHARABLE_CLASS(CEIntSockTest27) : public CEIntSockTestBase

   502 	{

   503 	public:

   504 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   505 		

   506 	private:

   507 		CEIntSockTest27(CProxyProvd* aProvd);

   508 		virtual TVerdict RunTestL();

   509 		void Cleanup();

   510 		

   511 		enum TState {EState1,EState2,EState3,EState4,EState5};

   512 		TState iState;

   513 

   514 		// the socket on which the operations in this test will happen

   515 		RInternalSocket iSocket;

   516 		TBuf8<20> iBuf;

   517 		TBuf8<40> iDisconnectBuf;

   518 		

   519 		TInetAddr iAddress;		

   520 	};

   521 	

   522 NONSHARABLE_CLASS(CEIntSockTest28A) : public CEIntSockTestBase

   523 	{

   524 	public:

   525 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   526 		

   527 	private:

   528 		enum TState {EState1,EState2};

   529 		CEIntSockTest28A(CProxyProvd* aProvd);

   530 		virtual TVerdict RunTestL();

   531 		void Cleanup();

   532 		RInternalSocket iSocket;

   533 		TState iState;

   534 		TBuf8<20> iBuf;

   535 		TInetAddr iAddress;		

   536 	};

   537 	

   538 NONSHARABLE_CLASS(CEIntSockTest28B) : public CEIntSockTestBase

   539 	{

   540 	public:

   541 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   542 		

   543 	private:

   544 		enum TState {EState1,EState2,EState3,EState4};

   545 		CEIntSockTest28B(CProxyProvd* aProvd);

   546 		virtual TVerdict RunTestL();

   547 		void Cleanup();

   548 		RInternalSocket iSocket;

   549 		RInternalSocket iNewSock;

   550 		TState iState;

   551 		TBuf8<20> iBuf;

   552 	};

   553 

   554 NONSHARABLE_CLASS(CEIntSockTest29) : public CEIntSockTestBase

   555 	{

   556 	public:

   557 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   558 		

   559 	private:

   560 		enum TState {EState1,EState2,EState3,EState4};

   561 		CEIntSockTest29(CProxyProvd* aProvd);

   562 		virtual TVerdict RunTestL();

   563 		void Cleanup();

   564 		RInternalSocket iSocket;

   565 		TState iState;

   566 		TSockXfrLength iVolume;

   567 		TBuf8<20> iBuf;

   568 		TInetAddr iAddress;		

   569 	};

   570 

   571 NONSHARABLE_CLASS(CEIntSockTest30) : public CEIntSockTestBase

   572 	{

   573 	public:

   574 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   575 		

   576 	private:

   577 		enum TState {EState1,EState2,EState3,EState4};

   578 		CEIntSockTest30(CProxyProvd* aProvd);

   579 		virtual TVerdict RunTestL();

   580 		void Cleanup();

   581 		RInternalSocket iSocket;

   582 		TState iState;

   583 		TSockXfrLength iVolume;

   584 		TBuf8<20> iBuf;

   585 		TInetAddr iAddress;	

   586 		TPtr8 iRecvBufPtr;	

   587 	};

   588 

   589 NONSHARABLE_CLASS(CEIntSockTest31) : public CEIntSockTestBase

   590 	{

   591 	public:

   592 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   593 		

   594 	private:

   595 		enum TState {EState1,EState2,EState3,EState4};

   596 		CEIntSockTest31(CProxyProvd* aProvd);

   597 		virtual TVerdict RunTestL();

   598 		void Cleanup();

   599 		RInternalSocket iSocket;

   600 		TState iState;

   601 		TSockXfrLength iVolume;

   602 		TBuf8<20> iBuf;

   603 		RMBufChain iRecvChain;

   604 		RMBufChain iSendChain;

   605 		TInetAddr iAddress;		

   606 	};

   607 

   608 NONSHARABLE_CLASS(CEIntSockTest32) : public CEIntSockTestBase

   609 	{

   610 	public:

   611 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   612 		

   613 	private:

   614 		enum TState {EState1,EState2,EState3,EState4};

   615 		CEIntSockTest32(CProxyProvd* aProvd);

   616 		virtual TVerdict RunTestL();

   617 		void Cleanup();

   618 		RInternalSocket iSocket;

   619 		TState iState;

   620 		TSockXfrLength iVolume;

   621 		TBuf8<20> iBuf;

   622 		RMBufChain iRecvChain;

   623 		RMBufChain iSendChain;	

   624 		TInetAddr iAddress;					

   625 	};

   626 

   627 NONSHARABLE_CLASS(CEIntSockTest33) : public CEIntSockTestBase

   628 	{

   629 	public:

   630 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   631 		

   632 	private:

   633 		enum TState {EState1,EState2,EState3,EState4};

   634 		CEIntSockTest33(CProxyProvd* aProvd);

   635 		virtual TVerdict RunTestL();

   636 		void Cleanup();

   637 		RInternalSocket iSocket;

   638 		TState iState;

   639 		TBuf8<20> iBuf;

   640 		TInetAddr iAddress;				

   641 		TPtr8 iReadBufPtr;

   642 	};

   643 	

   644 NONSHARABLE_CLASS(CEIntSockTest34) : public CEIntSockTestBase

   645 	{

   646 	public:

   647 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   648 		

   649 	private:

   650 		enum TState {EState1,EState2,EState3};

   651 		CEIntSockTest34(CProxyProvd* aProvd);

   652 		virtual TVerdict RunTestL();

   653 		void Cleanup();

   654 		RInternalSocket iSocket;

   655 		TState iState;

   656 		TInetAddr iAddress;				

   657 	};

   658 	

   659 NONSHARABLE_CLASS(CEIntSockTest35) : public CEIntSockTestBase

   660 	{

   661 	public:

   662 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   663 		

   664 	private:

   665 		enum TState {EState1, EState2, EState3, EState4 };

   666 		CEIntSockTest35(CProxyProvd* aProvd);

   667 		virtual TVerdict RunTestL();

   668 		void Cleanup();

   669 		RInternalSocket iSocket;

   670 		TState iState;

   671 		static const TInt KExpectedError = -4567; // Something random.

   672 		TInetAddr iAddress;			

   673 	};

   674 

   675 NONSHARABLE_CLASS(CEIntSockTest36) : public CEIntSockTestBase

   676 	{

   677 	public:

   678 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   679 		

   680 	private:

   681 		enum TState {EState1, EState2, EState3, EState4};

   682 

   683 		CEIntSockTest36(CProxyProvd* aProvd);

   684 		virtual TVerdict RunTestL();

   685 		void Cleanup();

   686 

   687 		RInternalSocket iSocket;

   688 		TState iState;

   689 		TBuf8<20> iBuf;

   690 		TInetAddr iAddress;			

   691 	};

   692 

   693 NONSHARABLE_CLASS(CEIntSockTest37) : public CEIntSockTestBase

   694 	{

   695 	public:

   696 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   697 		

   698 	private:

   699 		enum TState {EState1, EState2, EState3, EState4};

   700 

   701 		CEIntSockTest37(CProxyProvd* aProvd);

   702 		virtual TVerdict RunTestL();

   703 		void Cleanup();

   704 

   705 		RInternalSocket iSocket;

   706 		TState iState;

   707 		TBuf8<20> iBuf;

   708 		RMBufChain iSendChain;

   709 		RMBufChain iRecvChain;

   710 		TInetAddr iAddress;			

   711 	};

   712 

   713 NONSHARABLE_CLASS(CEIntSockTest38) : public CEIntSockTestBase

   714 	{

   715 	public:

   716 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   717 		

   718 	private:

   719 		enum TState {EState1, EState2, EState3, EState4, EState5};

   720 

   721 		CEIntSockTest38(CProxyProvd* aProvd);

   722 

   723 		virtual TVerdict RunTestL();

   724 		void Cleanup();

   725 

   726 		RInternalSocket iSocket;

   727 		TState iState;

   728 		TBuf8<20> iBuf;

   729 		TInetAddr iAddress;			

   730 	};

   731 

   732 NONSHARABLE_CLASS(CEIntSockTest39) : public CEIntSockTestBase

   733 	{

   734 	public:

   735 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   736 		

   737 	private:

   738 		enum TState {EState1, EState2, EState3};

   739 

   740 		CEIntSockTest39(CProxyProvd* aProvd);

   741 

   742 		virtual TVerdict RunTestL();

   743 		void Cleanup();

   744 

   745 		RInternalSocket iSocket;

   746 		TState iState;

   747 	};

   748 

   749 NONSHARABLE_CLASS(CEIntSockTest40) : public CEIntSockTestBase

   750 	{

   751 	public:

   752 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   753 		

   754 	private:

   755 		enum TState {EState1, EState2, EState3, EState4};

   756 

   757 		CEIntSockTest40(CProxyProvd* aProvd);

   758 

   759 		virtual TVerdict RunTestL();

   760 		void Cleanup();

   761 

   762 		RInternalSocket iSocket;

   763 		TState iState;

   764 	};

   765 

   766 NONSHARABLE_CLASS(CEIntSockTest41) : public CEIntSockTestBase

   767 	{

   768 	public:

   769 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   770 		

   771 	private:

   772 		enum TState {EState1, EState2, EState3};

   773 

   774 		CEIntSockTest41(CProxyProvd* aProvd);

   775 

   776 		virtual TVerdict RunTestL();

   777 		void Cleanup();

   778 		

   779 		TBuf8<20>	iBuf;

   780 		RInternalSocket iSocket;

   781 		TState iState;

   782 		TInetAddr iRemoteAddr;

   783 		TInetAddr iDestAddr;

   784 	};

   785 

   786 NONSHARABLE_CLASS(CEIntSockTest42) : public CEIntSockTestBase

   787 	{

   788 	public:

   789 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   790 		

   791 	private:

   792 		enum TState {EState1, EState2, EState3};

   793 

   794 		CEIntSockTest42(CProxyProvd* aProvd);

   795 

   796 		virtual TVerdict RunTestL();

   797 		void Cleanup();

   798 		

   799 		RMBufChain iSendChain;

   800 		RMBufChain iRecvChain;

   801 		TBuf8<20> iBuf;

   802 		RInternalSocket iSocket;

   803 		TState iState;

   804 		TInetAddr iRemoteAddr;

   805 		TInetAddr iDestAddr;

   806 	};

   807 

   808 NONSHARABLE_CLASS(CEIntSockTest43) : public CEIntSockTestBase

   809 	{

   810 	public:

   811 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   812 		

   813 	private:

   814 		enum TState {EState1, EState2, EState3};

   815 

   816 		CEIntSockTest43(CProxyProvd* aProvd);

   817 

   818 		virtual TVerdict RunTestL();

   819 		void Cleanup();

   820 		

   821 		TBuf8<20>	iBuf;

   822 		RInternalSocket iSocket;

   823 		TState iState;

   824 		TInetAddr iRemoteAddr;

   825 		TInetAddr iDestAddr;

   826 		TSockXfrLength iLength;

   827 	};

   828 

   829 NONSHARABLE_CLASS(CEIntSockTest44) : public CEIntSockTestBase

   830 	{

   831 	public:

   832 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   833 		

   834 	private:

   835 		enum TState {EState1, EState2, EState3, EState4};

   836 

   837 		CEIntSockTest44(CProxyProvd* aProvd);

   838 

   839 		virtual TVerdict RunTestL();

   840 		void Cleanup();

   841 		

   842 		RMBufChain iSendChain;

   843 		RMBufChain iRecvChain;

   844 		TBuf8<20> iBuf;

   845 		RInternalSocket iSocket;

   846 		TState iState;

   847 		TInetAddr iRemoteAddr;

   848 		TInetAddr iDestAddr;

   849 		TSockXfrLength iLength;		

   850 	};

   851 

   852 NONSHARABLE_CLASS(CEIntSockTest45) : public CEIntSockTestBase

   853 	{

   854 	public:

   855 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   856 		

   857 	private:

   858 		enum TState {EState1,EState2,EState3,EState4};

   859 		CEIntSockTest45(CProxyProvd* aProvd);

   860 		virtual TVerdict RunTestL();

   861 		void Cleanup();

   862 		RInternalSocket iSocket;

   863 		TState iState;

   864 		TBuf8<20> iBuf;

   865 		RMBufChain iSendChain;

   866 		RMBufChain iRecvChain;

   867 		TInetAddr iDestAddr;

   868 	};

   869 

   870 NONSHARABLE_CLASS(CEIntSockTest46) : public CEIntSockTestBase

   871 	{

   872 	public:

   873 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   874 		

   875 	private:

   876 		enum TState {EState1,EState2,EState3,EState4};

   877 		CEIntSockTest46(CProxyProvd* aProvd);

   878 		virtual TVerdict RunTestL();

   879 		void Cleanup();

   880 		RInternalSocket iSocket;

   881 		TState iState;

   882 		TBuf8<20> iBuf;		

   883 		TSockXfrLength iLength;	

   884 		TInetAddr 	iDestAddr;	

   885 	};

   886 

   887 NONSHARABLE_CLASS(CEIntSockTest47) : public CEIntSockTestBase

   888 	{

   889 	public:

   890 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   891 		

   892 	private:

   893 		enum TState {EState1,EState2};

   894 		CEIntSockTest47(CProxyProvd* aProvd);

   895 		virtual TVerdict RunTestL();

   896 		void Cleanup();

   897 		RInternalSocket iSocket;

   898 		TState iState;

   899 	};

   900 

   901 NONSHARABLE_CLASS(CEIntSockTest48) : public CEIntSockTestBase

   902 	{

   903 	public:

   904 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   905 		

   906 	private:

   907 		enum TState {EState1,EState2,EState3,EState4};

   908 		CEIntSockTest48(CProxyProvd* aProvd);

   909 		virtual TVerdict RunTestL();

   910 		void Cleanup();

   911 		RInternalSocket iSocket;

   912 		TState iState;

   913 	};

   914 

   915 NONSHARABLE_CLASS(CEIntSockTest49) : public CEIntSockTestBase

   916 	{

   917 	public:

   918 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   919 		

   920 	private:

   921 		enum TState {EState1,EState2,EState3,EState4,EState5};

   922 		CEIntSockTest49(CProxyProvd* aProvd);

   923 		virtual TVerdict RunTestL();

   924 		void Cleanup();

   925 		RInternalSocket iSocket;

   926 		TState iState;

   927 		TInetAddr iAddress;

   928 	};

   929 

   930 NONSHARABLE_CLASS(CEIntSockTest50) : public CEIntSockTestBase

   931 	{

   932 	public:

   933 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   934 		

   935 	private:

   936 		enum TState {EState1,EState2};

   937 		CEIntSockTest50(CProxyProvd* aProvd);

   938 		virtual TVerdict RunTestL();

   939 		void Cleanup();

   940 		RInternalSocket iSocket;

   941 		TState iState;

   942 	};

   943 

   944 NONSHARABLE_CLASS(CEIntSockTest51) : public CEIntSockTestBase

   945 	{

   946 	public:

   947 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   948 		

   949 	private:

   950 		enum TState {EState1,EState2,EState3,EState4};

   951 		CEIntSockTest51(CProxyProvd* aProvd);

   952 		virtual TVerdict RunTestL();

   953 		void Cleanup();

   954 		RInternalSocket iSocket;

   955 		TState iState;

   956 	};

   957 

   958 NONSHARABLE_CLASS(CEIntSockTest52) : public CEIntSockTestBase

   959 	{

   960 	public:

   961 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   962 		

   963 	private:

   964 		enum TState {EState1,EState2,EState3,EState4};

   965 		CEIntSockTest52(CProxyProvd* aProvd);

   966 		virtual TVerdict RunTestL();

   967 		void Cleanup();

   968 		RInternalSocket iAcceptingSocket;

   969 		RInternalSocket iSocket;		

   970 		TState iState;

   971 	};

   972 

   973 

   974 NONSHARABLE_CLASS(CEIntSockTest53) : public CEIntSockTestBase

   975 	{

   976 	public:

   977 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

   978 		

   979 	private:

   980 		void ConstructL();

   981 		~CEIntSockTest53();

   982 		CEIntSockTest53(CProxyProvd* aProvd);

   983 		virtual TVerdict RunTestL();

   984 		void Cleanup();

   985 		

   986 		enum TState {EState1,EState2,EState3,EState4,EState5};

   987 		TState iState;

   988 

   989 		// the socket on which the operations in this test will happen

   990 		RInternalSocket iSocket;

   991 		TBuf8<10> iRecvBuf;

   992 		TBuf8<20> iSendBuf;

   993 

   994 		CAggregateCollection* iColl;

   995 		CAggregateItem* iRecvItem;

   996 		CAggregateItem* iSendItem;

   997 		

   998 		TInetAddr		iAddress;

   999 	};

  1000 

  1001 NONSHARABLE_CLASS(CEIntSockTest54) : public CEIntSockTestBase

  1002 	{

  1003 	public:

  1004 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1005 		

  1006 	private:

  1007 		enum TState {EState1,EState2,EState3};

  1008 		CEIntSockTest54(CProxyProvd* aProvd);

  1009 		virtual TVerdict RunTestL();

  1010 		void Cleanup();

  1011 		RInternalSocket iSocket;		

  1012 		TState iState;

  1013 		TBuf8<10> iRecvBuf;		

  1014 		TInetAddr	iAddress;

  1015 		TSockXfrLength iLen;			

  1016 

  1017 	};

  1018 

  1019 NONSHARABLE_CLASS(CEIntSockTest55) : public CEIntSockTestBase

  1020 	{

  1021 	public:

  1022 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1023 		

  1024 	private:

  1025 		enum TState {EState1,EState2};

  1026 		CEIntSockTest55(CProxyProvd* aProvd);

  1027 		virtual TVerdict RunTestL();

  1028 		void Cleanup();

  1029 		RInternalSocket iSocket;		

  1030 		TState iState;

  1031 		TBuf8<10> iSendBuf;		

  1032 		TInetAddr	iAddress;

  1033 	};

  1034 

  1035 NONSHARABLE_CLASS(CEIntSockTest56) : public CEIntSockTestBase

  1036 	{

  1037 	public:

  1038 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1039 		

  1040 	private:

  1041 		enum TState {EState1,EState2};

  1042 		CEIntSockTest56(CProxyProvd* aProvd);

  1043 		virtual TVerdict RunTestL();

  1044 		void Cleanup();

  1045 		RInternalSocket iSocket;		

  1046 		TState iState;

  1047 		TBuf8<10> iSendBuf;		

  1048 	};

  1049 

  1050 NONSHARABLE_CLASS(CEIntSockTest57) : public CEIntSockTestBase

  1051 	{

  1052 	public:

  1053 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1054 		

  1055 	private:

  1056 		enum TState {EState1,EState2,EState3,EState4,EState5,EState6};

  1057 		CEIntSockTest57(CProxyProvd* aProvd);

  1058 		~CEIntSockTest57();

  1059 		void ConstructL();

  1060 		virtual TVerdict RunTestL();

  1061 		void Cleanup();

  1062 		RInternalSocket iSocket;		

  1063 		TState iState;

  1064 		TBuf8<10> iSendBuf;		

  1065 		TBuf8<10> iRecvBuf;

  1066 		TSockXfrLength iRecvLen;

  1067 		CAggregateCollection* iColl;

  1068 		CAggregateItem* iShutdownItem;

  1069 		CAggregateItem* iRecvItem;	

  1070 		CAggregateItem* iSendItem;					

  1071 	};

  1072 	

  1073 NONSHARABLE_CLASS(CEIntSockTest58) : public CEIntSockTestBase

  1074 	{

  1075 	public:

  1076 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1077 		

  1078 	private:

  1079 		enum TState {EState1,EState2,EState3};

  1080 		CEIntSockTest58(CProxyProvd* aProvd);

  1081 		virtual TVerdict RunTestL();

  1082 		void Cleanup();

  1083 		RInternalSocket iAcceptingSocket;

  1084 		RInternalSocket iSocket;		

  1085 		TState iState;

  1086 	};

  1087 

  1088 NONSHARABLE_CLASS(CEIntSockTest59) : public CEIntSockTestBase

  1089 	{

  1090 	public:

  1091 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1092 		

  1093 	private:

  1094 		enum TState {EState1, EState2, EState3,EState4};

  1095 

  1096 		CEIntSockTest59(CProxyProvd* aProvd);

  1097 

  1098 		virtual TVerdict RunTestL();

  1099 		void Cleanup();

  1100 		

  1101 		RMBufChain iSendChain;

  1102 		RMBufChain iRecvChain;

  1103 		TBuf8<20> iBuf;

  1104 		RInternalSocket iSocket;

  1105 		TState iState;

  1106 		TInetAddr iRemoteAddr;

  1107 		TInetAddr iDestAddr;

  1108 		TSockXfrLength iLength;		

  1109 	};

  1110 

  1111 NONSHARABLE_CLASS(CEIntSockTest60) : public CEIntSockTestBase

  1112 	{

  1113 	public:

  1114 		static CEIntSockTestBase* NewL(CProxyProvd* aProvd);

  1115 		

  1116 	private:

  1117 		enum TState {EState1,EState2,EState3,EState4,EState5,EState6,EState7,EState8};

  1118 		CEIntSockTest60(CProxyProvd* aProvd);

  1119 		~CEIntSockTest60();

  1120 		void ConstructL();

  1121 		virtual TVerdict RunTestL();

  1122 		void Cleanup();

  1123 		RInternalSocket iSocketIn;		

  1124 		RInternalSocket iSocketOut;				

  1125 		TState iState;

  1126 		TBuf8<64> iRecvBuf;		

  1127 		TBuf8<64> iRecvBuf2;

  1128 		TBuf8<64> iSendBuf;

  1129 		TSockXfrLength iRecvLen;

  1130 		CAggregateCollection* iColl;

  1131 		CAggregateItem* iRecvItem;	

  1132 		CAggregateItem* iSendItem;	

  1133 		TInetAddr		iInetAddrTo;

  1134 		TInetAddr		iInetAddrFrom;				

  1135 	};