diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/test/TE_ESock/EsockTestSection29.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/test/TE_ESock/EsockTestSection29.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,469 @@ +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// This contains ESock Test cases from section 29 +// +// + + +// EPOC includes +#include +#include +#include +#include +#include + +#ifdef SYMBIAN_OLD_EXPORT_LOCATION +#include "es_dummy.h" +#else +#include +#endif + +#include +#include + +#include "EsockTestSection29.h" + +// Test system includes +#include + + +TVerdict CEsockTest29::easyTestStepL() + { + + // Open Sockets, one to manipulate mBufPool and one to send/revieve with tcp or udp + TESTL( OpenSockets() == KErrNone ); + + // Bind Test Socket To local Address + TInetAddr local; + SetPort( local, KPort, KLocal ); + iTestSocket.Bind( local ); + + // Connect Test Socket to LoopBack Address + TInetAddr loopBack; + SetPort( loopBack, KPort, KLoopback ); + ConnectSocketL( iTestSocket, loopBack ); + + // Gobble all the Buf's in the MBuf Pool return the number of mBufs in Use + TInt totalUsedBufs = iDummySocket.SetOpt( KDummyOptionSetGobbleMBufs, 0, 0 ); + TInt bufsToBeFreed = 0; + + // Data to be used during socket Send + GetIntFromConfig(KSection29, KBufSize, iBufSize); + TBool keepSending = ETrue; + TBuf8<4500> recvBuf; + TBuf8<4500> sendData; + sendData.Fill(TChar('z'), iBufSize ); + TRequestStatus sendStatus; + TRequestStatus recvStatus; + const TInt KOneSecond = 1000000; + + + + for( TInt freeBufCounter = 0; freeBufCounter < totalUsedBufs && keepSending; freeBufCounter += bufsToBeFreed ) + // OOB loop that will gradually release more MBufs + { + + // release some mBufs and send + iDummySocket.SetOpt( KDummyOptionSetFreeSomeMBufs, bufsToBeFreed , 0); + iTestSocket.Send( sendData, 0, sendStatus ); + + // Wait for a second to allow time for server/protocol to send + User::After( KOneSecond ); + + // Cancel the send and start to recv + iTestSocket.CancelSend(); + User::WaitForRequest(sendStatus); + + iTestSocket.Recv(recvBuf, 0, recvStatus); + + // Wait for a second to allow time for server/protocol to recieve + User::After( KOneSecond ); + iTestSocket.CancelRecv(); + User::WaitForRequest( recvStatus ); + + if( freeBufCounter % 5 == 0 ) + { + INFO_PRINTF2( _L("freeBufs now >= %d "), freeBufCounter ); + } + + if( recvBuf.Compare(sendData) == 0 ) + // if we have recieved data then exit the loop + { + keepSending = EFalse; + } + + bufsToBeFreed = 2; + + } + + // Now do a regular send for good measure to make sure everything is ok + sendData.Fill(TChar('c'), iBufSize ); + INFO_PRINTF1( _L("End of Loop, Now sending....") ); + iTestSocket.Send( sendData, 0, sendStatus ); + User::WaitForRequest( sendStatus ); + INFO_PRINTF2( _L("Send Returned %d, now recieving...."), sendStatus.Int() ); + iTestSocket.Recv( recvBuf, 0, recvStatus ); + User::After( KOneSecond ); + iTestSocket.CancelRecv(); + User::WaitForRequest( recvStatus ); + + INFO_PRINTF2( _L("Recieve returned %d ") , recvStatus.Int() ); + if( recvBuf.Compare(sendData) != 0 ) + { + return EFail; + } + + return EPass; + + } + + +TInt CEsockTest29::OpenSockets() +// Func to open the sockets + { + iSockServ.Connect(); + GetStringFromConfig(KSection29, KTestSocketType, iProtocol); + TInt err = OpenDummySocket(); + if(err != KErrNone) + { + return err; + } + if( iProtocol.Compare(KUdp) == 0 ) + { + err = OpenTestUdpSocket(); + INFO_PRINTF1( _L("UDP Test Socket Opened") ); + } + else + { + err = OpenTestTcpSocket(); + INFO_PRINTF1( _L("TCP Test Socket Opened") ); + } + return err; + } + + +CEsockTest29::~CEsockTest29() + { + iTestSocket.Close(); + iDummySocket.Close(); + iSockServ.Close(); + } + + +TInt CEsockTest29::OpenTestTcpSocket() + { + return iTestSocket.Open(iSockServ, KAfInet, KSockStream, KProtocolInetTcp); + } + + +TInt CEsockTest29::OpenTestUdpSocket() + { + return iTestSocket.Open(iSockServ, KAfInet, KSockDatagram, KProtocolInetUdp); + } + + +TInt CEsockTest29::OpenDummySocket() + { + return iDummySocket.Open(iSockServ,_L("Dummy Protocol 3")); + } + + +void CEsockTest29::SetPort(TInetAddr &aAddr, const TInt aPort, const TDesC &aIPAddr) + { + aAddr.SetPort(aPort); + aAddr.Input(aIPAddr); + } + + +void CEsockTest29::ConnectSocketL( RSocket &aSocket, TInetAddr &aAddr ) +// Connect aSocket to aAddr + { + TRequestStatus connectSocketStatus; + aSocket.Connect( aAddr, connectSocketStatus ); + User::WaitForRequest( connectSocketStatus ); + if(connectSocketStatus != KErrNone) + { + User::Leave(KErrCouldNotConnect); + } + } + +const TDesC& CEsockTest29::GetTestName() + { + // store the name of this test case + _LIT(ret,"Test29"); + return ret; + } + + +/* -------------------------------------------------------------------------------------------- + ESOCK Test 29_1 uses the above Loop with a data size of 100 (less than MTU) and a Udp Socket + changing the OOB loop to do this is done with the use of ini files + -------------------------------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------------------------------------- + ESOCK Test 29_2 uses the above Loop with a data size of 4500 (Greater than MTU) and a Udp Socket + ------------------------------------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------------------------------------- + ESOCK Tests 29_3 to 29_9 are left open for further OOB loop tests + ------------------------------------------------------------------------------------------------*/ + + + +/* Test 29.10 */ + +// Test step 29.10 +const TDesC& CEsockTest29_10::GetTestName() + { + _LIT(ret,"Test29.10"); + return ret; + } + +CEsockTest29_10::~CEsockTest29_10() + { + } + +enum TVerdict CEsockTest29_10::easyTestStepL( void ) + { + SetTestStepResult(EFail); + TInt ret; + const TUint KOneSecond = 1000000; + + Logger().WriteFormat(_L("Send/ Recv on PDummy3 socket but no avail MBuf Memory, mBuf becomes avail after send")); + RSocketServ ss; + ret = ss.Connect(); + TESTL(KErrNone == ret); + + // open dummy prot 3 + Logger().WriteFormat(_L("Openning Dummy Protocol 3")); + RSocket sock; + ret = sock.Open(ss,_L("Dummy Protocol 3")); + TESTL(KErrNone == ret); + + // connect socket + TSockAddr addr; + TRequestStatus connStat; + sock.Connect(addr, connStat); + User::WaitForRequest(connStat); + TESTL(KErrNone == connStat.Int()); + + // send packet 1 + TRequestStatus stat; + Logger().WriteFormat(_L("Attempting to create a packet to receive later")); + _LIT8(sendDataOne, "First Send"); + sock.Send(sendDataOne,0,stat); + User::WaitForRequest(stat); + TESTL(KErrNone == stat.Int()); + // wait for packets to go through esock + User::After(KOneSecond * 2); + // gobble mBufs + TInt nFree = 0; + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); + while (nFree > 0) + { + ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + } + Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret); + + // we are running in high priority and allocating in a loop. + // so kernel may not be able to enlarge the pools. + // wait for kernel to enlarge the pool + // We have to come out from the loop as well. + User::After(KOneSecond * 2); + + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); + while (nFree > 0) + { + ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + } + Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret); + // Once again + User::After(KOneSecond * 2); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); + while (nFree > 0) + { + ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + } + Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret); + // Once again + User::After(KOneSecond * 2); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); + while (nFree > 0) + { + ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + } + // Once again + User::After(KOneSecond * 2); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); + while (nFree > 0) + { + ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); + sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); + } + + + // send packet 2 + User::After(KOneSecond); + TRequestStatus stat2; + _LIT8(sendDataTwo, "Second Send"); + Logger().WriteFormat(_L("Sending Data - Should never complete")); + sock.Send(sendDataTwo,0,stat2); + + User::After(KOneSecond); + Logger().WriteFormat(_L("Now cancel the Send")); + sock.CancelSend(); + User::WaitForRequest(stat2); + TESTL(stat2 == KErrCancel); + + Logger().WriteFormat(_L("Receiving Data -- expected to pick up sendDataOne")); + TBuf8<100> buf; + TRequestStatus stat3; + sock.Recv(buf, 0, stat3); + User::After(KOneSecond); + User::WaitForRequest(stat3); + TESTL(buf.Compare(sendDataOne) == 0); + + // send packet 3 + _LIT8(sendDataThree, "Third Send"); + Logger().WriteFormat(_L("Sending Data ... again")); + TRequestStatus stat4; + sock.Send(sendDataThree,0,stat4); + User::After(1000); + + // free memory + Logger().WriteFormat(_L("Now free memory - should get send and receive completion")); + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetFreeMBufs Option in Protocol")); + ret = sock.SetOpt(KDummyOptionSetFreeMBufs, 0, 0); + Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret); + TESTL(KErrNone == ret); + + Logger().WriteFormat(_L("Sending Data - Should now complete")); + User::WaitForRequest(stat4); + TESTL(stat4.Int() == KErrNone); + + // recieve data and compare contents to sent data + Logger().WriteFormat(_L("Receiving Data")); + sock.Recv(buf, 0, stat); + User::WaitForRequest(stat); + Logger().WriteFormat(_L("Recv has returned %d"), stat.Int()); + TBuf<100> buf16; + buf16.Copy(buf); + if(buf.Compare(sendDataThree) == 0) + { + SetTestStepResult(EPass); + } + + Logger().WriteFormat(_L("Data Recv'ed is '%S'"), &buf16); + sock.Close(); + ss.Close(); + return TestStepResult(); + } + +/* Test 29.11 */ + +// Test step 29.11 +const TDesC& CEsockTest29_11::GetTestName() + { + _LIT(ret,"Test29.11"); + return ret; + } + +CEsockTest29_11::~CEsockTest29_11() + { + } + +enum TVerdict CEsockTest29_11::easyTestStepL( void ) + { + TVerdict verdict = EFail; + TInt ret; + + Logger().WriteFormat(_L("Send/ Recv on PDummy3 socket but no avail MBuf Memory, mBuf becomes avail after send")); + RSocketServ ss; + ret = ss.Connect(); + TESTL(KErrNone == ret); + CleanupClosePushL(ss); + + // open dummy prot 3 + Logger().WriteFormat(_L("Openning Dummy Protocol 3")); + RSocket sock; + ret = sock.Open(ss,_L("Dummy Protocol 3")); + TESTL(KErrNone == ret); + + // connecti socket + TSockAddr addr; + TRequestStatus stat; + sock.Connect(addr, stat); + User::WaitForRequest(stat); + TESTL(KErrNone == stat.Int()); + + // drain MBuf Pool + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); + ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); + Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret); + + // send data and wait for 1/10 seconds + Logger().WriteFormat(_L("Sending Data")); + _LIT8( sendData, "bla bla bla bla"); + sock.Send(sendData,0,stat); + const TUint KTenMilliSecs = 10000; + User::After(KTenMilliSecs); + + // free all mbufs + Logger().WriteFormat(_L("Attempting to set KDummyOptionSetFreeMBufs Option in Protocol")); + ret = sock.SetOpt(KDummyOptionSetFreeMBufs, 0, 0); + TESTL(ret == KErrNone); + Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret); + + // wait for send to return + User::WaitForRequest(stat); + Logger().WriteFormat(_L("Send has returned %d"), stat.Int()); + if(stat.Int() != KErrNone) + { + verdict = EFail; + } + + // recieve data and verify that it is the same as send data + TBuf8<20> recvBuf; + TRequestStatus recvStatus; + sock.Recv(recvBuf, 0, recvStatus); + User::WaitForRequest(recvStatus); + Logger().WriteFormat(_L("recieving data on PDummy3 has returned %d"), recvStatus.Int()); + if(recvStatus.Int() != KErrNone) + { + verdict = EFail; + } + Logger().WriteFormat(_L("Comparing Recieved data and Sent data"), recvStatus.Int()); + if(recvBuf.Compare(sendData) == 0) + { + verdict = EPass; + } + + sock.Close(); + CleanupStack::PopAndDestroy(&ss); + SetTestStepResult(verdict); + return verdict; + + } +