applayerprotocols/httptransportfw/Test/T_HttpPipeliningTest/cpipeliningtestengine.cpp
// 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"
#include "CDEF143497.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);
CDEF143497* def143497 = CDEF143497::NewL(*iTestUtils);
CleanupStack::PushL(def143497);
RunTestL(*def143497);
CleanupStack::PopAndDestroy(def143497);
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;
}