diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/httputils/Test/Integration/TestInetProtUtilsSuite/Src/TestInetProUtilsUriServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericservices/httputils/Test/Integration/TestInetProtUtilsSuite/Src/TestInetProUtilsUriServer.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,288 @@ +// Copyright (c) 2007-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: +// Contains implementation of CTestInetProUtilsUriServer class +// +// + +/** + @file + @internalTechnology +*/ + +// User Includes +// Test Server +#include "TestInetProUtilsUriServer.h" + +// Test steps +#include "TestNormaliseUriStep.h" +#include "TestEscapeEncodeUriStep.h" +#include "TestTelUriParsingStep.h" +#include "TestTelUriValidationStep.h" + +_LIT(KTxtEPOC32Test, "InetProtUtilsServer"); + +#if (!defined EKA2) +// The system-wide unique name for the test-server +_LIT(KServerName, "TestInetProUtilsUriServer"); +#endif + +/** + Static factory constructor. Creates and returns instance of the test server + @internalTechnology + @test + @return A pointer to the newly created CTestInetProUtilsUriServer object +*/ +CTestInetProUtilsUriServer* CTestInetProUtilsUriServer::NewL() + { + // Construct the server + CTestInetProUtilsUriServer* server = new(ELeave) CTestInetProUtilsUriServer(); + CleanupStack::PushL(server); + + // CServer base class call + // Name the server using the system-wide unique string + // Clients use this to create server sessions. + server->StartL(server->ServerName()); + + CleanupStack::Pop(server); + return server; + } + + +#if (!defined EKA2) +/** + Creates the Active Scheduler, then creates the test-server, synchronises the + thread with the client and then enters the active scheduler. + + This is EKA1 version of MainL(). Uses sempahore to sync with client + as Rendezvous calls are not available +*/ +LOCAL_C void MainL() + { + // Create and install the active scheduler. + CActiveScheduler* sched = new(ELeave) CActiveScheduler; + CleanupStack::PushL(sched); + CActiveScheduler::Install(sched); + + // Create the server inside trap harness + CTestInetProUtilsUriServer* server = NULL; + TRAPD(err, server = CTestInetProUtilsUriServer::NewL()); + if (!err) + { + CleanupStack::PushL(server); + RSemaphore sem; + + // The client API of TestExecute will already have created the + // semaphore and will be waiting on it. + User::LeaveIfError(sem.OpenGlobal(KServerName)); + + CleanupStack::Pop(server); + + // Signal the client + sem.Signal(); + sem.Close(); + + // Enter the active scheduler + sched->Start(); + } + delete server; + CleanupStack::PopAndDestroy(sched); + } +#else +/** + EKA2 version of MainL() + Uses the new Rendezvous call isntead of the older semaphore. +*/ +LOCAL_C void MainL() + { + // For platform security +#if (defined __DATA_CAGING__) + RProcess().DataCaging(RProcess::EDataCagingOn); + RProcess().SecureApi(RProcess::ESecureApiOn); +#endif + CActiveScheduler* sched = new(ELeave) CActiveScheduler; + CActiveScheduler::Install(sched); + CTestInetProUtilsUriServer* server = NULL; + + // Create the test-server + TRAPD(err, server = CTestInetProUtilsUriServer::NewL()); + + if(!err) + { + // Sync with the client and enter the active scheduler + RProcess::Rendezvous(KErrNone); + sched->Start(); + } + delete server; + delete sched; + } +#endif // #if (!defined EKA2) + + +#if (defined __WINS__ && !defined EKA2) +/** + DLL entry-point for EKA1 emulator builds. +*/ +GLDEF_C TInt E32Dll(enum TDllReason /*aDllReason*/) + { + return KErrNone; + } +#else +/** + Exe entry point code, for EKA1 hardware and EKA2 builds. +*/ +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if (cleanup == NULL) + { + return KErrNoMemory; + } + + TRAPD(error, MainL()); + __ASSERT_ALWAYS(!error, User::Panic(KTxtEPOC32Test, error)); + delete cleanup; + __UHEAP_MARKEND; + return KErrNone; + } +#endif // #if (defined __WINS__ && !defined EKA2) + +#if (defined __WINS__ && !defined EKA2) +/** + For EKA1 emulator builds. This function is called when the thread is first + resumed. Has the standard thread entry siganture. + @internalTechnology + @test + @return KErrNone if everything is fine or system-wide error if any +*/ +TInt ThreadFunc (TAny* /*aParam*/) + { + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if (cleanup == NULL) + { + return KErrNoMemory; + } + + TRAPD(err, MainL()); + __ASSERT_ALWAYS(!err, User::Panic(KTxtEPOC32Test, err)); + delete cleanup; + __UHEAP_MARKEND; + return KErrNone; + } + +/** + For EKA1 emulator builds. Creates and starts a thread for the server to run. + @internalTechnology + @test + @param None + @return Integer value indicating the error code. +*/ +EXPORT_C TInt NewServer() + { + _LIT(KThread, "Thread"); + RThread thread; + + // Name the thread as "Thread" making it hopefully unique + TBuf threadName(KServerName); + threadName.Append(KThread); + + const TInt KMaxHeapSize = 0x1000000; + + // Create the thread + TInt err = thread.Create(threadName, ThreadFunc, KDefaultStackSize, + KMinHeapSize, KMaxHeapSize, NULL, EOwnerProcess + ); + if (err != KErrNone) + { + return err; + } + + // Start the thread -> effectively calls ThreadFunc + thread.Resume(); + + thread.Close(); + return KErrNone; + } +#endif // #if (defined __WINS__ && !defined EKA2) + + +/** + Base class pure virtual + @internalTechnology + @test + @param Descriptor containing the test-step name + @return Instance of the test step +*/ +CTestStep* CTestInetProUtilsUriServer::CreateTestStep(const TDesC& aStepName) + { + CTestStep* testStep = NULL; + TRAPD(err,testStep=CreateTestStepL(aStepName)); + if(err == KErrNone) + return testStep; + else + return NULL; + } + +CTestStep* CTestInetProUtilsUriServer::CreateTestStepL(const TDesC& aStepName) + { + CTestStep* testStep = NULL; + + if (aStepName == KTestNormaliseUriStep) + { + testStep = new (ELeave) CTestNormaliseUriStep(); + } + else if (aStepName == KTestEscapeEncodeUriStep) + { + testStep = new (ELeave) CTestEscapeEncodeUriStep(); + } + else if (aStepName == KTestTelUriParsingStep) + { + testStep = new (ELeave) CTestTelUriParsingStep(); + } + else if (aStepName == KTestTelUriValidationStep) + { + testStep = new (ELeave) CTestTelUriValidationStep(); + } + else if (aStepName == KTestOomNormaliseUriStep) + { + testStep = new (ELeave) CTestNormaliseUriOomStep(); + } + else if (aStepName == KTestOomTelUriValidationStep) + { + testStep = new (ELeave) CTestTelUriValidationOomStep(); + } + + return testStep; + } + +/** + Returns server name based on the EKA version + @internalTechnology + @test + @return Descriptor containing the servername +*/ +const TPtrC CTestInetProUtilsUriServer::ServerName() + { +#if (!defined EKA2) + return KServerName(); +#else + // The exe name can be either TestInetProUtilsUriServer or + // TestInetProUtilsUriServer_Cap based on whether the normal + // or the security tests are being run. So decide the server + // name during runtime + TParsePtrC serverName(RProcess().FileName()); + return serverName.Name(); +#endif + }