diff -r 000000000000 -r f5a58ecadc66 servicediscoveryandcontrol/pnp/test/upnp/unittests/tcpserver/src/ptcpservertests.cpp --- /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 +#include +#include +#include +#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 resultFilePath; + TBuf 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 xmlLogFile(xmlFilePath); + TBuf logFile; + TBuf 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 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 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(" Failed: TestCase:..... ")); + 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 () ) + { + const TCFFactory::TPeerFoundOrCreated& msg = message_cast < const TCFFactory::TPeerFoundOrCreated > ( aMessage ); + iTcpServer = msg.iNodeId; + CompleteSelf ( KErrNone ); + } + else if ( aMessage.IsMessage () + || aMessage.IsMessage () ) + { + CompleteSelf ( KErrNone ); + } + } + + + + + +