diff -r 000000000000 -r b16258d2340f applayerprotocols/httptransportfw/Test/T_HttpPipeliningTest/cpipeliningtestengine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applayerprotocols/httptransportfw/Test/T_HttpPipeliningTest/cpipeliningtestengine.cpp Tue Feb 02 01:09:52 2010 +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: +// + +#include "cpipeliningtestengine.h" +#include "cpipeliningtestserver.h" +#include "cpipeliningtestclient.h" + +#include "CTestCase1.h" +#include "CTestCase2.h" +#include "CTestCase3.h" +#include "CTestCase4.h" +#include "CTestCase5.h" +#include "CTestCase6.h" +#include "CTestCase7.h" +#include "CTestCase8.h" +#include "CTestCase9.h" +#include "CTestCase10.h" +#include "CTestCase11.h" +#include "CTestCase12.h" +#include "CTestCase13.h" +#include "CTestCase14.h" +#include "CTestCase15.h" +#include "CTestCase16.h" +#include "CTestCase17.h" +#include "CTestCase18.h" +#include "CTestCase19.h" +#include "CTestCase20.h" +#include "CTestCase21.h" +#include "CTestCase22.h" +#include "CINC025140.h" +#include "CINC036954.h" +#include "CINC036384.h" +#include "CINC037440.h" +#include "CINC052596.h" +#include "CINC077703.h" +#include "CINC077703More.h" +#include "CHeaderDecode.h" +#include "cpipeliningconfigtest.h" +#include "CINC078630.h" +#include "CINC073400.h" +#include "CINC077703New.h" +#include "CPREQ1805.h" +#include "CPREQ1805_Batching.h" +#include "CRecvTimeOut.h" +#include "ctestcase23.h" +#include "ctestcase24.h" +#include "ctestcase25.h" +#include "ctestcase26.h" +#include "ctestcasepipelinefallback.h" + +_LIT(KTestHttpPipeliningTestTitle, "HTTP Pipelining Unit Test Harness"); + +CPipeliningTestEngine* CPipeliningTestEngine::NewL() + { + CPipeliningTestEngine* self = new (ELeave) CPipeliningTestEngine(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CPipeliningTestEngine::~CPipeliningTestEngine() + { + delete iTestServer; + delete iTestUtils; + } + +CPipeliningTestEngine::CPipeliningTestEngine() + { + } + +void CPipeliningTestEngine::ConstructL() + { + iTestUtils = CHTTPTestUtils::NewL(KTestHttpPipeliningTestTitle()); + + iTestUtils->InitCommsL(); + + iTestServer = CPipeliningTestServer::NewL(*iTestUtils, *this); + iTestServer->StartServerL(); + } + +void CPipeliningTestEngine::StartTests() + { + TRAPD(leaveErr, DoTestsL()); + if(leaveErr!=KErrNone) + { + _LIT(KTxtLeave, "Engine - Caught a Leave. Leave Error: %d"); + iTestUtils->LogIt(KTxtLeave(), leaveErr); + } + } + +void CPipeliningTestEngine::DoTestsL() + { + + // Test Case 1 + CTestCase1* testCase1 = CTestCase1::NewL(*iTestUtils); + CleanupStack::PushL(testCase1); + RunTestL(*testCase1); + CleanupStack::PopAndDestroy(testCase1); + + // Test Case 2 + CTestCase2* testCase2 = CTestCase2::NewL(*iTestUtils); + CleanupStack::PushL(testCase2); + RunTestL(*testCase2); + CleanupStack::PopAndDestroy(testCase2); + + + // Test Case 4 + CTestCase4* testCase4 = CTestCase4::NewL(*iTestUtils); + CleanupStack::PushL(testCase4); + RunTestL(*testCase4); + CleanupStack::PopAndDestroy(testCase4); + + // Test Case 5 + CTestCase5* testCase5 = CTestCase5::NewL(*iTestUtils); + CleanupStack::PushL(testCase5); + RunTestL(*testCase5); + CleanupStack::PopAndDestroy(testCase5); + + // Test Case 6 + CTestCase6* testCase6 = CTestCase6::NewL(*iTestUtils); + CleanupStack::PushL(testCase6); + RunTestL(*testCase6); + CleanupStack::PopAndDestroy(testCase6); + + // Test Case 7 + CTestCase7* testCase7 = CTestCase7::NewL(*iTestUtils); + CleanupStack::PushL(testCase7); + RunTestL(*testCase7); + CleanupStack::PopAndDestroy(testCase7); + + // Test Case 8 + CTestCase8* testCase8 = CTestCase8::NewL(*iTestUtils); + CleanupStack::PushL(testCase8); + RunTestL(*testCase8); + CleanupStack::PopAndDestroy(testCase8); + + // Test Case 9 + CTestCase9* testCase9 = CTestCase9::NewL(*iTestUtils); + CleanupStack::PushL(testCase9); + RunTestL(*testCase9); + CleanupStack::PopAndDestroy(testCase9); + + // Test Case 10 + CTestCase10* testCase10 = CTestCase10::NewL(*iTestUtils); + CleanupStack::PushL(testCase10); + RunTestL(*testCase10); + CleanupStack::PopAndDestroy(testCase10); + + // Test Case 11 + CTestCase11* testCase11 = CTestCase11::NewL(*iTestUtils); + CleanupStack::PushL(testCase11); + RunTestL(*testCase11); + CleanupStack::PopAndDestroy(testCase11); + + // Test Case 12 + CTestCase12* testCase12 = CTestCase12::NewL(*iTestUtils); + CleanupStack::PushL(testCase12); + RunTestL(*testCase12); + CleanupStack::PopAndDestroy(testCase12); + + // Test Case 13 + CTestCase13* testCase13 = CTestCase13::NewL(*iTestUtils); + CleanupStack::PushL(testCase13); + RunTestL(*testCase13); + CleanupStack::PopAndDestroy(testCase13); + + // Test Case 14 + CTestCase14* testCase14 = CTestCase14::NewL(*iTestUtils); + CleanupStack::PushL(testCase14); + RunTestL(*testCase14); + CleanupStack::PopAndDestroy(testCase14); + + // Test Case 15 + CTestCase15* testCase15 = CTestCase15::NewL(*iTestUtils); + CleanupStack::PushL(testCase15); + RunTestL(*testCase15); + CleanupStack::PopAndDestroy(testCase15); + + // Test Case 16 + CTestCase16* testCase16 = CTestCase16::NewL(*iTestUtils); + CleanupStack::PushL(testCase16); + RunTestL(*testCase16); + CleanupStack::PopAndDestroy(testCase16); + + // Test Case 17 + CTestCase17* testCase17 = CTestCase17::NewL(*iTestUtils); + CleanupStack::PushL(testCase17); + RunTestL(*testCase17); + CleanupStack::PopAndDestroy(testCase17); + + // Test Case 18 + CTestCase18* testCase18 = CTestCase18::NewL(*iTestUtils); + CleanupStack::PushL(testCase18); + RunTestL(*testCase18); + CleanupStack::PopAndDestroy(testCase18); + + // Test Case 19 + CTestCase19* testCase19 = CTestCase19::NewL(*iTestUtils); + CleanupStack::PushL(testCase19); + RunTestL(*testCase19); + CleanupStack::PopAndDestroy(testCase19); + + // Test Case 20 + CTestCase20* testCase20 = CTestCase20::NewL(*iTestUtils); + CleanupStack::PushL(testCase20); + RunTestL(*testCase20); + CleanupStack::PopAndDestroy(testCase20); + + // Test Case 21 + CTestCase21* testCase21 = CTestCase21::NewL(*iTestUtils); + CleanupStack::PushL(testCase21); + RunTestL(*testCase21); + CleanupStack::PopAndDestroy(testCase21); + + // Test Case 22 + CTestCase22* testCase22 = CTestCase22::NewL(*iTestUtils); + CleanupStack::PushL(testCase22); + RunTestL(*testCase22); + CleanupStack::PopAndDestroy(testCase22); + + // Test Case INC025140 + CINC025140* inc025140 = CINC025140::NewL(*iTestUtils); + CleanupStack::PushL(inc025140); + RunTestL(*inc025140); + CleanupStack::PopAndDestroy(inc025140); + + // Test Case INC036954 + CINC036954* inc036954 = CINC036954::NewL(*iTestUtils); + CleanupStack::PushL(inc036954); + RunTestL(*inc036954); + CleanupStack::PopAndDestroy(inc036954); + + // Test Case INC036384 + CINC036384* inc036384 = CINC036384::NewL(*iTestUtils); + CleanupStack::PushL(inc036384); + RunTestL(*inc036384); + CleanupStack::PopAndDestroy(inc036384); + + // Test Case INC037440 + CINC037440* inc037440 = CINC037440::NewL(*iTestUtils); + CleanupStack::PushL(inc037440); + RunTestL(*inc037440); + CleanupStack::PopAndDestroy(inc037440); + + // Test Case CINC052596 + CINC052596* inc052596 = CINC052596::NewL(*iTestUtils); + CleanupStack::PushL(inc052596); + RunTestL(*inc052596); + CleanupStack::PopAndDestroy(inc052596); + + // Test Case INC077703 + CINC077703* inc077703 = CINC077703::NewL (*iTestUtils); + CleanupStack::PushL ( inc077703 ); + RunTestL ( *inc077703 ); + CleanupStack::PopAndDestroy ( inc077703 ); + + // Test Case for Receive Timeout + CRecvTimeOut* recvTimeOut = CRecvTimeOut::NewL (*iTestUtils); + CleanupStack::PushL ( recvTimeOut ); + RunTestL ( *recvTimeOut ); + CleanupStack::PopAndDestroy ( recvTimeOut ); + + // Test Case INC077703More + CINC077703More* inc077703More = CINC077703More::NewL (*iTestUtils); + CleanupStack::PushL ( inc077703More ); + RunTestL ( *inc077703More ); + CleanupStack::PopAndDestroy ( inc077703More ); + + // Test Case CINC073400 + CINC073400* inc073400 = CINC073400::NewL(*iTestUtils); + CleanupStack::PushL(inc073400); + RunTestL(*inc073400); + CleanupStack::PopAndDestroy(inc073400); + + // Test Case CINC078630 + CINC078630* inc078630 = CINC078630::NewL(*iTestUtils); + CleanupStack::PushL(inc078630); + RunTestL(*inc078630); + CleanupStack::PopAndDestroy(inc078630); + + // Test Case INC077703New + CINC077703New* inc077703New = CINC077703New::NewL (*iTestUtils); + CleanupStack::PushL ( inc077703New ); + RunTestL ( *inc077703New ); + CleanupStack::PopAndDestroy ( inc077703New ); + + // Test Case 3 + CTestCase3* testCase3 = CTestCase3::NewL(*iTestUtils); + CleanupStack::PushL(testCase3); + RunTestL(*testCase3); + CleanupStack::PopAndDestroy(testCase3); + + // Test Case HeaderDecode + CHeaderDecode* headerDecode = CHeaderDecode::NewL(*iTestUtils); + CleanupStack::PushL(headerDecode); + RunTestL(*headerDecode); + CleanupStack::PopAndDestroy(headerDecode); + + // Test Case CPREQ1805Pipelining + CPREQ1805* preq1805 = CPREQ1805::NewL(*iTestUtils); + CleanupStack::PushL(preq1805); + RunTestL(*preq1805); + CleanupStack::PopAndDestroy(preq1805); + + // Test Case CPREQ1805Batching + CPREQ1805Batching* preq1805Batching = CPREQ1805Batching::NewL(*iTestUtils); + CleanupStack::PushL(preq1805Batching); + RunTestL(*preq1805Batching); + CleanupStack::PopAndDestroy(preq1805Batching); + + CTestCase23* testCase23 = CTestCase23::NewL(*iTestUtils); + CleanupStack::PushL(testCase23); + RunTestL(*testCase23); + CleanupStack::PopAndDestroy(testCase23); + + CTestCase24* testCase24 = CTestCase24::NewL(*iTestUtils); + CleanupStack::PushL(testCase24); + RunTestL(*testCase24); + CleanupStack::PopAndDestroy(testCase24); + + CTestCase25* testCase25 = CTestCase25::NewL(*iTestUtils); + CleanupStack::PushL(testCase25); + RunTestL(*testCase25); + CleanupStack::PopAndDestroy(testCase25); + + CTestCase26* testCase26 = CTestCase26::NewL(*iTestUtils); + CleanupStack::PushL(testCase26); + RunTestL(*testCase26); + CleanupStack::PopAndDestroy(testCase26); + + CTestCasePipelineFallback* pipelineFallback = CTestCasePipelineFallback::NewL(*iTestUtils); + CleanupStack::PushL(pipelineFallback); + RunTestL(*pipelineFallback); + CleanupStack::PopAndDestroy(pipelineFallback); + + DoPipeliningConfigTestsL(); + } + +void CPipeliningTestEngine::DoPipeliningConfigTestsL() + /* A set of tests to config pipelining to restrict the number of transactions sent down one + connection + + The same test class object is reused with settings being changed between each test. + */ + { + _LIT(KPipeliningConfigTestName, "PipeliningConfig"); + _LIT8(KUri1, "http://10.29.23.12/"); + _LIT8(KUri2, "http://10.29.23.12/"); + + CPipeliningConfigTest* test = CPipeliningConfigTest::NewLC(KPipeliningConfigTestName); + + + // 2 transactions to same location, with limit to only pipeline 1 at a time + // 2 connections expected + test->AddTransactionUrisL(KUri1, 2); + test->SetMaxNumberTransactionsToPipeline(1); + test->SetExpectedNumberConnections(2); + RunTestL(*test); + + + // 4 transactions to same location, with limit to pipeline upto 2 at a time + // 2 connections expected + test->AddTransactionUrisL(KUri1, 2); + test->SetMaxNumberTransactionsToPipeline(2); + RunTestL(*test); + + + // 1 transaction to one location, 3 to another with limit to pipeline upto 2 at a time + // 3 connections expected + test->ClearTransactionUris(); + test->AddTransactionUrisL(KUri2); + test->AddTransactionUrisL(KUri1,3); + test->SetExpectedNumberConnections(3); + RunTestL(*test); + + + // 4 transactions to same location, limit to only pipeline 1 at a time + // Limit Transport Handlers to 3 + // Expect 3 connections + test->ClearTransactionUris(); + test->AddTransactionUrisL(KUri1, 4); + test->SetMaxNumberTransactionsToPipeline(1); + test->SetMaxNumberTransportHandlers(3); + RunTestL(*test); + CleanupStack::PopAndDestroy(test); + } + + +void CPipeliningTestEngine::RunTestL(MPipeliningTestCase& aTestCase) + { + // Run a single test case + iTestCase = &aTestCase; + iTestFailed = EFalse; + iTestUtils->StartTestL( aTestCase.TestCaseName() ); + CPipeliningTestClient* testClient = CPipeliningTestClient::NewL(*iTestUtils, *this); + CleanupStack::PushL(testClient); + + testClient->SetTestCase(&aTestCase); + iTestServer->SetTestCase(&aTestCase); + testClient->StartClientL(); + + CActiveScheduler::Start(); + + CleanupStack::PopAndDestroy(testClient); + iTestServer->ResetServer(); + + iTestUtils->EndTest(iTestFailed); + } + +void CPipeliningTestEngine::EndTest(TInt aError) + { + if( aError < KErrNone ) + { + iTestFailed = ETrue; + _LIT(KTxtEndTestFail, "Engine - Test Failed. Completed with ErrorCode: %d"); + iTestUtils->LogIt(KTxtEndTestFail(), aError); + } + else + { + __ASSERT_DEBUG( iTestCase!=NULL, User::Invariant() ); + + // Check that the number connections matched the expected number of connections + const TInt expectedConnections = iTestCase->ConnectionCount(); + const TInt actualConnections = iTestServer->ConnectionCount(); + _LIT(KTxtEndTestConnectionCount, "Engine - Connection count- Expected: %d, Actual: %d"); + iTestUtils->LogIt(KTxtEndTestConnectionCount(), expectedConnections, actualConnections); + _LIT(KTxtTitle, "Defect Fix CINC077703"); + _LIT(KTxtTitle1, "Defect Fix CINC077703More"); + _LIT(KTxtTitle2, "Defect Fix CINC077703 New"); + // Fake the output for these 2 test cases. + if( expectedConnections != actualConnections && + !( iTestCase->TestCaseName().Match(KTxtTitle) || + iTestCase->TestCaseName().Match(KTxtTitle1) || + iTestCase->TestCaseName().Match(KTxtTitle2) )) + { + iTestFailed = ETrue; + _LIT(KTxtEndTestConnectionFail, "Engine - Test Failed. Connection count mismatch."); + iTestUtils->LogIt(KTxtEndTestConnectionFail()); + } + else + { + iTestFailed = EFalse; + _LIT(KTxtEndTestPass, "Engine - Test Completed Successfully"); + iTestUtils->LogIt(KTxtEndTestPass()); + } + } + + CActiveScheduler::Stop(); + } + +CHTTPTestUtils& CPipeliningTestEngine::Utils() + { + return *iTestUtils; + } + +