diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmservertest/TestMultipleAlarmsSuite/src/TestMultipleAlarmsServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmservertest/TestMultipleAlarmsSuite/src/TestMultipleAlarmsServer.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,307 @@ +// Copyright (c) 2005-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 CTestMultipleAlarmsServer class +// +// + +/** + @file + @internalTechnology +*/ + +// User Includes +#include "AlarmControlsManager.h" + +// Test Server +#include "TestMultipleAlarmsServer.h" + +// Test Steps +#include "TestStartAlertServerStep.h" +#include "TestWaitStep.h" +#include "TestCreateCalEntriesStep.h" +#include "TestAlarmSnoozeStep.h" +#include "TestAlarmControlStateStep.h" +#include "TestAlarmSnoozeStep.h" +#include "TestAlarmClearStep.h" +#include "TestAssociatedDataStep.h" +#include "TestKillAlertServerStep.h" +#include "TestCleanupStep.h" +#include "TestPerformanceStep.h" +#include "TestCreateEntriesOOMStep.h" +#include "TestAlarmContentOOMStep.h" + +// System Include +#include + +/*@{*/ +// The system-wide unique name for the test-server +_LIT(KServerName, "TestMultipleAlarmsServer"); +/*@}*/ + +/** +Static factory constructor. Creates and returns instance of the test server +@internalTechnology +@test +@return A pointer to the newly created CTestMultipleAlarmsServer object +*/ +CTestMultipleAlarmsServer* CTestMultipleAlarmsServer::NewL() + { + // Construct the server + CTestMultipleAlarmsServer* server = new(ELeave) CTestMultipleAlarmsServer(); + CleanupStack::PushL(server); + + server->ConstructL(); + + CleanupStack::Pop(server); + return server; + } + +/** +Second phase constructor. Calls base class onstructL. +And calls ShareAuto on the Logger session. +@internalTechnology +@test +*/ +void CTestMultipleAlarmsServer::ConstructL() + { + TInt error = KErrNone; + + // CTestServer base class call + // Names the server using the system-wide unique string + // and also starts the server's logger. This logger is used + // by the alert server thread + CTestServer::ConstructL(KServerName); + + // The dummy alarm control running from the alert server thread needs to + // share the test server's logger session to do some logging. As it is + // non-shareable by default unless we uncomment those lines in + // testexecute.cfg, we explicitly ShareAuto() it here. + error = Logger().ShareAuto(); + if(error != KErrNone) + { + INFO_PRINTF2(_L("Error occured while doing ShareAuto(): %D, The alert server thread will not perform any logging"), error); + } + else + { + iLogSessionShared = ETrue; + } + } + +/** +Destructor. +@internalTechnology +@test +*/ +CTestMultipleAlarmsServer::~CTestMultipleAlarmsServer() + { + } + +/** +EKA2 version of MainL() +Uses the new Rendezvous call instead 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); + CTestMultipleAlarmsServer* server = NULL; + + // Create the test-server + TRAPD(err, server = CTestMultipleAlarmsServer::NewL()); + + if(!err) + { + // Sync with the client and enter the active scheduler + RProcess::Rendezvous(KErrNone); + sched->Start(); + } + delete server; + delete sched; + } + +/** +Exe entry point code +*/ +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup *cleanup = CTrapCleanup::New(); + if (cleanup == NULL) + { + return KErrNoMemory; + } + TInt err = KErrNone; + TRAP(err, MainL()); + delete cleanup; + __UHEAP_MARKEND; + return KErrNone; + } + +/** +Base class pure virtual, called by TEF +@param aStepName Descriptor containing the test-step name +@return Instance of the test step +@internalTechnology +@test +*/ +CTestStep* CTestMultipleAlarmsServer::CreateTestStep(const TDesC& aStepName) + { + CTestStep *testStep = NULL; + + if (aStepName == KTestStartAlertServerStep) + { + testStep = new (ELeave) CTestStartAlertServerStep(*this); // Method could leave while construction + } + else if (aStepName == KTestWaitStep) + { + testStep = new (ELeave) CTestWaitStep(*this); + } + else if (aStepName == KTestCreateCalEntriesStep) + { + testStep = new (ELeave) CTestCreateCalEntriesStep(*this); + } + else if (aStepName == KTestAlarmControlStateStep) + { + testStep = new (ELeave) CTestAlarmControlStateStep(*this); + } + else if (aStepName == KTestAlarmSnoozeStep) + { + testStep = new (ELeave) CTestAlarmSnoozeStep(*this); + } + else if (aStepName == KTestAlarmClearStep) + { + testStep = new (ELeave) CTestAlarmClearStep(*this); + } + else if (aStepName == KTestAssociatedDataStep) + { + testStep = new (ELeave) CTestAssociatedDataStep(*this); + } + else if (aStepName == KTestKillAlertServerStep) + { + testStep = new (ELeave) CTestKillAlertServerStep(*this); + } + else if (aStepName == KTestCleanupStep) + { + testStep = new (ELeave) CTestCleanupStep(*this); + } + else if (aStepName == KTestPerformanceStep) + { + testStep = new (ELeave) CTestPerformanceStep(*this); + } + else if (aStepName == KTestCreateEntriesOOMStep) + { + testStep = new (ELeave) CTestCreateEntriesOOMStep(*this); + } + else if (aStepName == KTestAlarmContentOOMStep) + { + testStep = new (ELeave) CTestAlarmContentOOMStep(*this); + } + return testStep; + } + +/** +Returns a refernce to the current max alarms value. Set by the +TestStartAlertServerStep +@return A reference to the current max alarms value +@internalTechnology +@test +*/ +TInt& CTestMultipleAlarmsServer::CurrentMaxAlarms() + { + return iCurrentMaxAlarms; + } + +/** +Returns the current max alarms value. Set by the TestStartAlertServerStep +@return The current max alarms value +@internalTechnology +@test +*/ +TInt CTestMultipleAlarmsServer::CurrentMaxAlarms() const + { + return iCurrentMaxAlarms; + } + +/** +Returns a reference to the pointer to CAlarmControlsManager +@return Reference to the pointer to CAlarmControlsManager +@internalTechnology +@test +*/ +CAlarmControlsManager*& CTestMultipleAlarmsServer::AlarmControlsManager() + { + return iAlmCtrlsMgr; + } + +/** +Returns a reference to the pointer to CEikServAlarmAlertServer +@return Reference to the pointer to CEikServAlarmAlertServer +@internalTechnology +@test +*/ +CEikServAlarmAlertServer*& CTestMultipleAlarmsServer::AlertServer() + { + return iAlertServer; + } + +/** +Returns the number of currently notifying alarms +This flag is incremented / decremented when CDummyAlarmControls are +notified of alarms that expire +@return The number of currently notifying alarms +@internalTechnology +@test +*/ +TInt& CTestMultipleAlarmsServer::NoOfCurrentlyNotifyingAlarms() + { + return iNoOfCurrentlyNotifyingAlarms; + } +/** +Returns the Id of the alarm which was the last to start playing +@return The Id of the alarm which was the last to start playing +@internalTechnology +@test +*/ +TAlarmId& CTestMultipleAlarmsServer::CurrentlyPlayingAlarmId() + { + return iCurrentlyPlayingAlarmId; + } + +/** +Returns a refernce to the thread that starts Alert Server +@return Refernce to the thread that starts Alert Server +@internalTechnology +@test +*/ +RThread& CTestMultipleAlarmsServer::AltSrvThread() + { + return iAltSrvThread; + } + +/** +Returns whether we were successful in making the Logger shareable between threads +@return Whether we were successful in making the Logger shareable between threads +@internalTechnology +@test +*/ +TBool CTestMultipleAlarmsServer::LogSessionShared() + { + return iLogSessionShared; + }