--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/servicediscoveryandcontrol/pnp/test/upnp/unittests/tcpserver/src/ptcpservertests.cpp Tue Feb 02 01:12:20 2010 +0200
@@ -0,0 +1,523 @@
+/*
+* Copyright (c) 2008 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:
+*
+*/
+
+#include <ss_glob.h>
+#include <comms-infras/ss_thread.h>
+#include <comms-infras/ss_nodemessages_factory.h>
+#include <comms-infras/ss_nodemessages_dataclient.h>
+#include "ptcpservertests.h"
+#include "upnp_cf_msgs.h"
+#include "upnpflowbase.h"
+#include "upnpflowfactory.h"
+
+#include "ctcpservertestupnp1.h"
+#include "ctcpservertestupnp2.h"
+#include "ctcpservertestupnp3.h"
+#include "ctcpservertestupnp4.h"
+#include "ctcpservertestupnp5.h"
+#include "ctcpservertestupnp6.h"
+#include "ctcpservertestupnp7.h"
+#include "ctcpservertestupnp8.h"
+#include "ctcpservertestupnp9.h"
+#include "ctcpservertestupnp10.h"
+#include "ctcpservertestupnp11.h"
+#include "CTcpServerTestUPnP12.h"
+#include "CTcpServerTestUPnP13.h"
+#include "CTcpServerTestUPnP14.h"
+#include "CTcpServerTestUPnP15.h"
+#include "CTcpServerTestUPnP16.h"
+#include "CTcpServerTestUPnP17.h"
+#include "CTcpServerTestUPnP18.h"
+#include "CTcpServerTestUPnP19.h"
+#include "CTcpServerTestUPnP20.h"
+#include "CTcpServerTestUPnP21.h"
+#include "CTcpServerTestUPnP22.h"
+
+#include "CTcpServerTestCase.h"
+#include "CTcpServerTestUPnP23.h"
+#include "CTcpServerTestUPnP24.h"
+#include "CTcpServerTestUPnP25.h"
+#include "CTcpServerTestUPnP26.h"
+#include "CTcpServerTestUPnP27.h"
+#include "CTcpServerTestUPnP28.h"
+#include "CTcpServerTestUPnP29.h"
+#include "CTcpServerTestUPnP30.h"
+#include "CTcpServerTestUPnP31.h"
+#include "CTcpServerTestUPnP32.h"
+#include "CTcpServerTestUPnP33.h"
+#include "CTcpServerTestUPnP34.h"
+#include "CTcpServerTestUPnP41.h"
+
+//const TUint16 KActivityNull = 0;
+const TUint KHttpDefaultPort = 80;
+//Add Blocks of 64
+static const TInt KBlockSize1 = 64;
+static const TInt KMinGrowth1 = 30;
+static const TInt KThresholdGrowth1 = 30;
+static const TInt KInitialAllocation1 = 128;
+
+static const TInt KHeapSize = 1024 * 1024; //1MB
+
+using namespace Messages;
+
+_LIT8 ( KTestUPnPServiceUri,"http://127.0.0.1:80/testserviceuri1" );
+_LIT8 ( KMissingHost, "GET /testserviceuri1 HTTP/1.1\r\nContent-Length: 0\r\n\r\n");
+_LIT8 ( KExpectedResponse, "HTTP/1.1 400 Bad request");
+
+//-------------------------------------------------------------------------------------------------
+// CTcpServerTestBase
+//-------------------------------------------------------------------------------------------------
+
+#define BEGIN_TESTLIST
+
+#define ADD_TEST(name) \
+ if (aTestName == _L(#name))\
+ {\
+ return CTcpServer ## name::NewL(aProvd);\
+ }
+
+#define END_TESTLIST \
+ User::Leave(KErrNotSupported);\
+ return NULL;
+
+CTcpServerTestBase* CTcpServerTestBase::CreateTestL(const TDesC& aTestName, CProxyProvd* aProvd)
+ {
+ BEGIN_TESTLIST
+
+ ADD_TEST(TestUPnP)
+ ADD_TEST(TestUPnP1)
+ ADD_TEST(TestUPnP2)
+ ADD_TEST(TestUPnP3)
+ ADD_TEST(TestUPnP4)
+ ADD_TEST(TestUPnP5)
+ ADD_TEST(TestUPnP6)
+ ADD_TEST(TestUPnP7)
+ ADD_TEST(TestUPnP8)
+ ADD_TEST(TestUPnP9)
+ ADD_TEST(TestUPnP10)
+ ADD_TEST(TestUPnP11)
+ ADD_TEST(TestUPnP12)
+ ADD_TEST(TestUPnP13)
+ ADD_TEST(TestUPnP14)
+ ADD_TEST(TestUPnP15)
+ ADD_TEST(TestUPnP16)
+ ADD_TEST(TestUPnP17)
+ ADD_TEST(TestUPnP18)
+ ADD_TEST(TestUPnP19)
+ ADD_TEST(TestUPnP20)
+ ADD_TEST(TestUPnP21)
+ ADD_TEST(TestUPnP22)
+ ADD_TEST(TestUPnP23)
+ ADD_TEST(TestUPnP24)
+ ADD_TEST(TestUPnP25)
+ ADD_TEST(TestUPnP26)
+ ADD_TEST(TestUPnP27)
+ ADD_TEST(TestUPnP28)
+ ADD_TEST(TestUPnP29)
+ ADD_TEST(TestUPnP30)
+ ADD_TEST(TestUPnP31)
+ ADD_TEST(TestUPnP32)
+ ADD_TEST(TestUPnP33)
+ ADD_TEST(TestUPnP34)
+ ADD_TEST(TestUPnP35) //TcpServer Recv timeout
+ ADD_TEST(TestUPnP36) //TcpServer Recv timeout
+ ADD_TEST(TestUPnP37) //TcpServer Recv timeout
+ ADD_TEST(TestUPnP38) //Test Case failing
+ ADD_TEST(TestUPnP39)
+ ADD_TEST(TestUPnP40)
+ ADD_TEST(TestUPnP41)
+ ADD_TEST(TestUPnP42)
+
+ END_TESTLIST
+ }
+
+
+void CTcpServerTestBase::StartTestL(const TDesC& aTestName, CProxyProvd* aProvd)
+ {
+ CTcpServerTestBase* test = CreateTestL(aTestName,aProvd);
+ CleanupStack::PushL(test);
+ test->ConstructL();
+ CActiveScheduler::Add(test);
+ CleanupStack::Pop(test);
+ TRequestStatus* stat = &test->iStatus;
+ test->SetActive();
+ User::RequestComplete(stat,KErrNone);
+ }
+
+CTcpServerTestBase::CTcpServerTestBase(CProxyProvd* aProvd) :
+ CActive(EPriorityNormal),
+ iProvd(aProvd)
+ {}
+
+void CTcpServerTestBase::ConstructL()
+ {
+ //Create the Chunk Manager
+ CChunkManager* chkmgr = CChunkManager::NewL ( KHeapSize );
+ if ( chkmgr )
+ {
+ chkmgr->AddPoolL ( KBlockSize1, KInitialAllocation1, KMinGrowth1, KThresholdGrowth1 );
+ }
+
+ iChunkManager = chkmgr;
+
+ SetLoggerL();
+ }
+
+CTcpServerTestBase::~CTcpServerTestBase()
+ {
+ iLogger.Close();
+ delete iChunkManager;
+ }
+
+/** Override this function if you want cleanup to happen before the completion of
+ the test case. This function is called before the test is completed
+ */
+void CTcpServerTestBase::Cleanup()
+ {}
+
+/** Sets the test case as active again and prevents the object from being destroyed
+ when the RunL completes.
+
+ Note: The active object is not complete the request again automatically, if this behaviour is
+ desired the user must call User::RequestComplete
+ */
+void CTcpServerTestBase::Reschedule()
+ {
+ SetActive();
+ iReschedule = TRUE;
+ }
+
+void CTcpServerTestBase::CompleteSelf ( TInt aError )
+ {
+ TRequestStatus* pStat = &iStatus;
+ User::RequestComplete ( pStat, aError );
+ }
+
+/** Attaches the iLogger variable to the TestExecute Log Server. This enable this prt to write to
+ the testexecute logs as if it were running directly from TestExecute
+ */
+// SetLoggerL() is taken directly from CTestServer::StartLoggerL() in the TEF src TestServerBase.Cpp
+
+
+void CTcpServerTestBase::SetLoggerL()
+ {
+ // Create a cinidata object for parsing the testexecute.ini
+ CTestExecuteIniData* parseTestExecuteIni = NULL;
+ TBuf<KMaxTestExecuteNameLength> resultFilePath;
+ TBuf<KMaxTestExecuteNameLength> xmlFilePath;
+ TInt logMode;
+ TInt logLevel;
+
+ TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL());
+ if (err == KErrNone)
+ {
+ CleanupStack::PushL(parseTestExecuteIni);
+ parseTestExecuteIni->ExtractValuesFromIni();
+ parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, resultFilePath);
+ parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlFilePath);
+ parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);
+ parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);
+ }
+ else
+ {
+ resultFilePath.Copy(KTestExecuteLogPath);
+ xmlFilePath.Copy(KTestExecuteLogPath);
+ logMode = TLoggerOptions(ELogHTMLOnly);
+ logLevel = RFileFlogger::TLogSeverity(ESevrAll);
+ }
+ Logger().SetLoggerOptions(logMode);
+
+ // Initialise a handle to the file logger
+ User::LeaveIfError(Logger().Connect());
+ RFs fS;
+ User::LeaveIfError(fS.Connect());
+ CleanupClosePushL(fS);
+ RFile file;
+ TBuf<KMaxTestExecuteNameLength> xmlLogFile(xmlFilePath);
+ TBuf<KMaxTestExecuteNameLength> logFile;
+ TBuf<KMaxTestExecuteNameLength> logFileNameFile(resultFilePath);
+ logFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile);
+ if(file.Open(fS,logFileNameFile,EFileRead | EFileShareAny) != KErrNone)
+ {
+ // For the old flogger we have to create an individual file
+ _LIT(KTxtLog,"TEIntSock.txt");
+ logFile.Copy(KTxtLog);
+ logMode = TLoggerOptions(0);
+ Logger().SetLoggerOptions(logMode);
+ }
+ else
+ {
+ CleanupClosePushL(file);
+ TBuf8<KMaxTestExecuteNameLength> logFile8;
+ TInt fileSize;
+ User::LeaveIfError(file.Size(fileSize));
+ User::LeaveIfError(file.Read(logFile8,fileSize));
+ logFile.Copy(logFile8);
+ xmlLogFile.Append(logFile);
+ _LIT(KXmlExtension,".xml");
+ xmlLogFile.Append(KXmlExtension);
+ _LIT(KHtmExtension,".htm");
+ logFile.Append(KHtmExtension);
+ CleanupStack::Pop(&file);
+ file.Close();
+ }
+ TBuf<KMaxTestExecuteLogFilePath> logFilePath(resultFilePath);
+ logFilePath.Append(logFile);
+ CleanupStack::Pop(&fS);
+ fS.Close();
+
+ if (logMode == 0 || logMode == 2)
+ {
+ User::LeaveIfError(Logger().HtmlLogger().CreateLog(logFilePath, RTestExecuteLogServ::ELogModeAppend));
+ }
+ if (logMode == 1 || logMode == 2)
+ {
+ User::LeaveIfError(Logger().XmlLogger().CreateLog(xmlLogFile,RFileFlogger::ELogModeAppend));
+ Logger().XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(logLevel));
+ }
+ if (parseTestExecuteIni != NULL)
+ {
+ CleanupStack::PopAndDestroy(parseTestExecuteIni);
+ }
+ }
+
+
+
+/** Called by the active scheduler in order to run the test
+ */
+void CTcpServerTestBase::RunL()
+ {
+ iReschedule = EFalse;
+ TVerdict res = RunTestL();
+ if (!iReschedule)
+ {
+ Cleanup();
+ FinishTest(res);
+ delete this;
+ return;
+ }
+ }
+
+void CTcpServerTestBase::FinishTest(TVerdict aResult)
+ {
+ iProvd->TestComplete(aResult);
+ }
+
+void CTcpServerTestBase::DoCancel()
+ {
+ Cleanup();
+ }
+
+//------------------------------------------------------------//
+/////////////////// CTcpServerTestUPnP /////////////////////////
+////// Testcase: Send the test data from the test client/////////
+//------------------------------------------------------------//
+
+CTcpServerTestUPnP* CTcpServerTestUPnP::NewL ( CProxyProvd* aProvd )
+ {
+ CTcpServerTestUPnP* ret = new ( ELeave ) CTcpServerTestUPnP ( aProvd );
+ CleanupStack::PushL ( ret );
+ ret->ConstructL ();
+ CleanupStack::Pop ( ret );
+ return ret;
+ }
+
+CTcpServerTestUPnP::CTcpServerTestUPnP ( CProxyProvd* aProvd ) :
+ CTcpServerTestBase ( aProvd ), iSocketHandler ( *this ), iHostAddr ( KInetAddrLoop, KHttpDefaultPort ), iState ( ECreateServer )
+ {
+ }
+
+CTcpServerTestUPnP::~CTcpServerTestUPnP ()
+ {
+ iServiceUri.Close ();
+
+ iSocketHandler.CancelAll ();
+ iClientSocket.Close ();
+ delete iSocketOpener;
+
+ iTimer.Close ();
+
+ TUpnpMessage::DeRegister ();
+ }
+
+void CTcpServerTestUPnP::ConstructL ()
+ {
+ TUpnpMessage::RegisterL ( SockManGlobals::Get ()->SelfWorker ());
+
+ iServiceUri.CreateL ( KTestUPnPServiceUri );
+
+ iTimer.CreateLocal ();
+ TRAPD ( err, iSocketOpener = CSocketOpener::NewL ( *this ) );
+
+ User::LeaveIfError ( err );
+ }
+
+TVerdict CTcpServerTestUPnP::RunTestL ()
+ {
+ switch ( iState )
+ {
+ case ECreateServer:
+ {
+ const TUint8* uriPtr = NULL;
+ uriPtr = iServiceUri.Ptr ();
+
+ const TUid reqUid = { CUPnPFlowFactory::iUid };
+ THttpServerFlowQuery flowQuery ( uriPtr,
+ iServiceUri.Size (),
+ Id (),
+ EHttpServerFlow, iChunkManager );
+ TCFPlayerRole playerRole ( TCFPlayerRole::EDataPlane );
+
+ ESock::TCFFactory::TFindOrCreatePeer msg ( TCFPlayerRole::EDataPlane, reqUid, &flowQuery );
+ TNodeId factoryContainer = SockManGlobals::Get()->GetPlaneFC( playerRole );
+
+ RClientInterface::OpenPostMessageClose ( Id (), TNodeCtxId ( KActivityNull, factoryContainer ), TCFFactory::TFindOrCreatePeer ( TCFPlayerRole::EDataPlane, reqUid, &flowQuery ).CRef () );
+
+ iState = EStartServer;
+ iStatus = KRequestPending;
+ Reschedule ();
+ return EPass;
+ }
+
+ case EStartServer:
+ {
+ RClientInterface::OpenPostMessageClose ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iTcpServer ), TCFDataClient::TStart ().CRef () );
+
+ iState = EOpenClientSocketAndConnect;
+ iStatus = KRequestPending;
+ Reschedule ();
+ return EPass;
+ }
+
+ case EOpenClientSocketAndConnect:
+ {
+ iSocketOpener->MakeSocket ( KAfInet, KSockStream, KProtocolInetTcp );
+
+ iState = ESendData;
+ iStatus = KRequestPending;
+ Reschedule ();
+ return EPass;
+ }
+
+ case ESendData:
+ {
+ iSendChain.CreateL ( KMissingHost );
+ iSocketHandler.Send ( iSendChain );
+
+ iState = ESendStopServer;
+ iStatus = KRequestPending;
+ Reschedule ();
+ return EPass;
+ }
+
+ // just to make sure production objects are cleaned-up properly.
+ case ESendStopServer:
+ {
+ // cleanup tcp server flow
+ RClientInterface::OpenPostMessageClose ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iTcpServer ), TCFDataClient::TStop ( KErrNone ).CRef () );
+
+ iState = EServerStopped;
+ iStatus = KRequestPending;
+ Reschedule ();
+ return EPass;
+ }
+
+ case EServerStopped:
+ {
+ // cleanup udp server flow
+ RClientInterface::OpenPostMessageClose ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iTcpServer ), TEChild::TDestroy ().CRef () );
+
+ iTimer.After ( iStatus, 1000000 ); //1secs
+ iState = ECleanup;
+ iStatus = KRequestPending;
+ Reschedule ();
+ return EPass;
+ }
+
+ case ECleanup:
+ {
+ return iResponse; // Here the final test case is passed back to the RSocket::Ioctl
+ }
+
+ default:
+ {
+ iLogger.WriteFormat(_L("<i> Failed: TestCase:..... </i>"));
+ ASSERT(0);
+ return EFail;
+ }
+ }
+ }
+
+void CTcpServerTestUPnP::OpenComplete ( RInternalSocket& aSocket )
+ {
+ iClientSocket = aSocket;
+ iSocketHandler.Attach ( aSocket );
+
+ iSocketHandler.Connect ( iHostAddr );
+ }
+
+void CTcpServerTestUPnP::ConnectComplete ()
+ {
+ CompleteSelf ( KErrNone );
+ }
+
+void CTcpServerTestUPnP::SendComplete ( TInt /*aLength*/ )
+ {
+ iSendChain.Init ();
+ iSocketHandler.Recv ();
+ }
+
+void CTcpServerTestUPnP::RecvComplete ( RMBufChain& aData )
+ {
+ RBuf8 responseBuf;
+ responseBuf.CreateMax ( aData.Length () );
+ aData.CopyOut ( responseBuf );
+ aData.Free ();
+
+ if ( responseBuf.FindF ( KExpectedResponse ) == KErrNotFound )
+ {
+ iResponse = EFail; // test case failed
+ }
+ else
+ {
+ iResponse = EPass; // test case passed
+ }
+
+ responseBuf.Close ();
+ CompleteSelf ( KErrNone );
+ }
+
+void CTcpServerTestUPnP::ReceivedL ( const TRuntimeCtxId& /*aSender*/, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage )
+ {
+ if ( aMessage.IsMessage<TCFFactory::TPeerFoundOrCreated> () )
+ {
+ const TCFFactory::TPeerFoundOrCreated& msg = message_cast < const TCFFactory::TPeerFoundOrCreated > ( aMessage );
+ iTcpServer = msg.iNodeId;
+ CompleteSelf ( KErrNone );
+ }
+ else if ( aMessage.IsMessage<TCFDataClient::TStarted> ()
+ || aMessage.IsMessage<TCFDataClient::TStopped> () )
+ {
+ CompleteSelf ( KErrNone );
+ }
+ }
+
+
+
+
+
+