--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lbstest/lbstestproduct/lbshybridmolr/src/ctlbshybridmolrserver.cpp Tue Feb 02 01:50:39 2010 +0200
@@ -0,0 +1,287 @@
+// 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:
+// @file CTLbsHybridMTLRServer.cpp
+// This is the class implementation for the LBS Hybrid MOLR Test Server
+//
+//
+
+// System includes
+#include <e32std.h>
+#include <rsshared.h>
+
+// User includes
+#include "ctlbshybridmolrserver.h"
+#include "ctlbsstepsetuproamselflocate.h"
+#include "ctlbsstepconfighybridmodule.h"
+
+#include "ctlbsuebasedmolrself.h"
+#include "ctlbsueassistedmolrselfgpslate.h"
+#include "ctlbsueassistedmolrselfgpsinaccurate.h"
+#include "ctlbsstepsetupprotocolstub.h"
+#include "ctlbshybridueassistedmolrgpsok.h"
+#include "ctlbsueassistedmolrselfgpsinaccuratetimeout.h"
+#include "ctlbsueassistedmolrselfgpslatefacilitytimeout.h"
+#include "ctlbsautonomousmolrfutile.h"
+#include "ctlbshybridmolrfutile.h"
+#include "ctlbshybriduebasedmolrpartial.h"
+#include "ctlbshybridueassistedmolrpartial.h"
+#include "ctlbshybridueassistedmolrclienttimeout.h"
+#include "ctlbshybridueassistedmolrtimeout.h"
+#include "ctlbsmolrgpsoptions.h"
+#include "ctlbshybridueassistedmolrnogpsupdate.h"
+#include "ctlbsptamolrpartialearlycomplete.h"
+#include "ctlbsmolrtracking.h"
+#include "ctlbsmolrresetassistance.h"
+#include "ctlbsuebasedmolrselfinternalvaluestest.h"
+#include "ctlbssuplmolrtbfutilesp.h"
+#include "ctlbsuebasedmolronesl.h"
+#include "ctlbsmolrerrorassistance.h"
+
+/**
+ NewL()
+ Constructs a CT_LbsHybridMOLRServer object.
+ Uses two phase construction and leaves nothing on the CleanupStack.
+ @internalTechnology
+ @param none
+ @return Created object of type CT_LbsClientServer
+ @pre None
+ @post None
+*/
+CT_LbsHybridMOLRServer* CT_LbsHybridMOLRServer::NewL()
+ {
+ CT_LbsHybridMOLRServer*server = new(ELeave) CT_LbsHybridMOLRServer();
+ CleanupStack::PushL(server);
+ server->ConstructL(KLbsHybridMOLRTestServer);
+ CleanupStack::Pop(server);
+ return server;
+ }
+
+
+/**
+ MainL()
+ Description : This is the main function which installs the
+ active scheduler and creates a server
+ @internalTechnology
+ @param none
+ @return none
+ @pre None
+ @post None
+*/
+LOCAL_C void MainL()
+ {
+ CActiveScheduler* sched = new (ELeave) CActiveScheduler;
+ CleanupStack::PushL(sched);
+ CActiveScheduler::Install(sched);
+
+ __UHEAP_MARK;
+ // this registers the server with the active scheduler and calls SetActive
+ CT_LbsHybridMOLRServer* server = CT_LbsHybridMOLRServer::NewL();
+
+ // signal to the client that we are ready by
+ // rendevousing process
+ RProcess::Rendezvous(KErrNone);
+
+ // run the active scheduler
+ sched->Start();
+
+ // clean up
+ delete server;
+ __UHEAP_MARKEND;
+ CleanupStack::PopAndDestroy(sched);
+ }
+
+
+
+
+/**
+ E32Main()
+ Description : It is the entry point
+ @internalTechnology
+ @param none
+ @return Returns the error code
+ @pre None
+ @post None
+*/
+GLDEF_C TInt E32Main()
+ {
+ __UHEAP_MARK;
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+ if(cleanup == NULL)
+ {
+ return KErrNoMemory;
+ }
+
+ TRAPD(err, MainL());
+
+ delete cleanup;
+ __UHEAP_MARKEND;
+
+ return err;
+ }
+
+
+CT_LbsHybridMOLRServer::~CT_LbsHybridMOLRServer()
+ {
+ }
+
+
+/**
+ Function : CT_LbsHybridMOLRServer
+ Description : Constructor
+ @internalTechnology
+ @param :
+ @return : N/A
+ @precondition : none
+ @postcondition : none
+*/
+CT_LbsHybridMOLRServer::CT_LbsHybridMOLRServer()
+ {
+ }
+
+/**
+ Function : ConstructL
+ Description :
+ @internalTechnology
+ @param :
+ @return : N/A
+ @precondition : none
+ @postcondition : none
+*/
+void CT_LbsHybridMOLRServer::ConstructL(const TDesC& aName)
+ {
+ CT_LbsServer::ConstructL(aName);
+
+ iSharedData = CT_LbsHybridMOLRSharedData::NewL();
+ }
+
+
+/**
+ Function : CreateTestStep
+ Description : Creates a test step based on the step name read from the script file
+ @internalTechnology
+ @param : aStepName The step name which needs to be created
+ @return : Created object of type CTestStep
+ @precondition : none
+ @postcondition : none
+*/
+CTestStep* CT_LbsHybridMOLRServer::CreateTestStep(const TDesC& aStepName)
+ {
+ // NULL if insufficient memory. This suits the API.
+
+ // Test case test steps, each test step supports one or more test cases.
+ if (aStepName == KLbsStep_SetupRoamSelfLocate)
+ {
+ return CT_LbsStep_SetupRoamSelfLocate::New(*this);
+ }
+ else if(aStepName == KLbsStep_SetupProtocolStub)
+ {
+ return CT_LbsStep_SetupProtocolStub::New(*this);
+ }
+ else if(aStepName == KLbsStep_ConfigHybridModule)
+ {
+ return CT_LbsStep_ConfigHybridModule::New(*this);
+ }
+
+ else if(aStepName == KLbsUEBasedMOLRSelf)
+ {
+ return CT_LbsUEBasedMOLRSelf::New(*this);
+ }
+ else if (aStepName == KLbsUEAssistedMOLRSelfGPSLate)
+ {
+ return CT_LbsUEAssistedMOLRSelfGPSLate::New(*this);
+ }
+ else if (aStepName == KLbsUEAssistedMOLRSelfGPSInaccurate)
+ {
+ return CT_LbsUEAssistedMOLRSelfGPSInaccurate::New(*this);
+ }
+ else if(aStepName == KLbsUEAssistedMOLRSelfGPSInaccurateT)
+ {
+ return CT_LbsUEAssistedMOLRSelfGPSInaccurateT::New(*this);
+ }
+
+ else if(aStepName == KLbsHybridUEAssistedMOLRGPSOk)
+ {
+ return CT_LbsHybridUEAssistedMOLRGPSOk::New(*this);
+ }
+
+ else if (aStepName == KLbsAutonomousMOLRFutile)
+ {
+ return CT_LbsAutonomousMOLRFutile::New(*this);
+ }
+
+ else if (aStepName == KLbsHybridUEBasedMOLRPartial)
+ {
+ return CT_LbsHybridUEBasedMOLRPartial::New(*this);
+ }
+ else if (aStepName == KLbsHybridUEAssistedMOLRPartial)
+ {
+ return CT_LbsHybridUEAssistedMOLRPartial::New(*this);
+ }
+ else if (aStepName == KLbsUEAssistedMOLRSelfGPSLateFacTimeout)
+ {
+ return CT_LbsUEAssistedMOLRSelfGPSLateFacTimeout::New(*this);
+ }
+ else if (aStepName == KLbsHybridMOLRFutile)
+ {
+ return CT_LbsHybridMOLRFutile::New(*this);
+ }
+ else if (aStepName == KLbsUEAssistedMOLRClientTimeout)
+ {
+ return CT_LbsUEAssistedMOLRClientTimeout::New(*this);
+ }
+ else if (aStepName == KLbsHybridUEAssistedMOLRTimeOut)
+ {
+ return CT_LbsHybridUEAssistedMOLRTimeOut::New(*this);
+ }
+ else if (aStepName == KLbsMolrGpsOptions)
+ {
+ return CT_LbsMolrGpsOptions::New(*this);
+ }
+ else if (aStepName == KLbsHybridUEAssistedMOLRNoGPSUpdate)
+ {
+ return CT_LbsHybridUEAssistedMOLRNoGPSUpdate::New(*this);
+ }
+ else if (aStepName == KLbsPTAMOLRPartialEarlyComplete)
+ {
+ return CT_LbsPTAMOLRPartialEarlyComplete::New(*this);
+ }
+ else if (aStepName == KLbsMolrTracking)
+ {
+ return CT_LbsMolrTracking::New(*this);
+ }
+ else if (aStepName == KLbsMolrResetAssistance)
+ {
+ return CT_LbsMolrResetAssistance::New(*this);
+ }
+ else if (aStepName == KLbsUEBasedMOLRSelfInternalValueTest)
+ {
+ return CT_LbsUEBasedMOLRSelfInternalValueTest::New(*this);
+ }
+ else if (aStepName == KLbsSuplMolrTbFutileSp)
+ {
+ return CT_LbsSuplMolrTbFutileSp::New(*this);
+ }
+ else if (aStepName == KLbsUEBasedMOLROneSL)
+ {
+ return CT_LbsUEBasedMOLROneSL::New(*this);
+ }
+ else if (aStepName == KLbsMOLRErrorAssistance)
+ {
+ return CT_LbsMolrErrorAssistance::New(*this);
+ }
+
+ // Let base class handle any common test steps - will return NULL if test step is not supported.
+ return CT_LbsServer::CreateTestStep(aStepName);
+ }
+