--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lbs/lbsclient/src/ctlbsclientstepmultireq.cpp Thu Jan 21 12:53:44 2010 +0000
@@ -0,0 +1,463 @@
+// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// @file ctlbsclientstepmultireq.cpp
+// This is the class implementation for the Multi-Request Tests
+//
+//
+
+#include "ctlbsclientstepmultireq.h"
+
+#include <lbs.h>
+#include <lbscommon.h>
+#include <lbspositioninfo.h>
+#include <lbsipc.h>
+
+#include "tlbsutils.h"
+
+// constant definitions
+_LIT(KLbsClientStepMultiReq, "LbsClientStepMultiReq");
+
+
+/**
+ * Destructor
+ */
+CT_LbsClientStep_MultiReq::~CT_LbsClientStep_MultiReq()
+ {
+ delete iGetLastKnownPosAO;
+ delete iNotifyPosUpdateAO;
+ delete iTimer;
+ delete iTempPosInfo;
+ }
+
+
+/**
+ * Constructor
+ */
+CT_LbsClientStep_MultiReq::CT_LbsClientStep_MultiReq(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent), iState(EStateUnknown), iTempPosInfo(NULL)
+ {
+ SetTestStepName(KLbsClientStep_MultiReq);
+ }
+
+
+/**
+Static Constructor
+*/
+CT_LbsClientStep_MultiReq* CT_LbsClientStep_MultiReq::NewL(CT_LbsClientServer& aParent)
+ {
+ return new(ELeave) CT_LbsClientStep_MultiReq(aParent);
+ }
+
+
+/**
+Static Constructor
+*/
+CT_LbsClientStep_MultiReq* CT_LbsClientStep_MultiReq::New(CT_LbsClientServer& aParent)
+ {
+ return new CT_LbsClientStep_MultiReq(aParent);
+ // Note the lack of ELeave.
+ // This means that having insufficient memory will return NULL;
+ }
+
+
+/**
+ * Callback - called when NotifyPositionUpdate request completes
+ */
+void CT_LbsClientStep_MultiReq::NotifyPositionUpdateCallback(TRequestStatus& aStatus)
+/**
+ * Called when async NotifyPositionUpdate completes
+ */
+ {
+ TInt testCaseId;
+
+ if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
+ {
+ switch (testCaseId)
+ {
+ case 01: // multiple requests of different types
+ {
+ if(KErrNone == aStatus.Int())
+ {
+ switch(iState)
+ {
+ case EStateUnknown:
+ {
+ iState = EStateLastNotifyPositionUpdateComplete;
+ }
+ break;
+
+ case EStateLastKnownPositionComplete:
+ {
+ iState = EStateDone;
+ AsyncTidyUp();
+ // note: we'll now drop back into the main test step
+ }
+ break;
+
+ case EStateLastNotifyPositionUpdateComplete:
+ case EStateDone :
+ // fall through
+ default:
+ {
+ User::Panic(KLbsClientStepMultiReq, KErrUnknown);
+ }
+ break;
+ }
+ }
+ else
+ {
+ INFO_PRINTF2(_L("NotifyModuleStatusEvent completed. Status = %d"), aStatus.Int());
+ SetTestStepResult(EFail);
+ AsyncTidyUp();
+ }
+ }// end case 01
+ break;
+ case 02: //
+ {
+ switch(iState)
+ {
+ case EStateUnknown:
+ {
+ iState = EStateLastNotifyPositionUpdateComplete;
+ }
+ break;
+
+ case EStateLastKnownPositionComplete:
+ {
+ iState = EStateDone;
+ AsyncTidyUp();
+ }
+ break;
+
+ case EStateLastNotifyPositionUpdateComplete:
+ case EStateDone :
+ // fall through
+ default:
+ {
+ User::Panic(KLbsClientStepMultiReq, KErrUnknown);
+ }
+ break;
+ }
+ }
+ break;
+ default:
+ {
+ User::Panic(KLbsClientStepMultiReq, KErrUnknown);
+ }
+
+ }// end switch testCaseId
+ }// end if GetIntFromConfig
+ }
+
+
+
+/**
+ * Callback - called when GetLastKnownPosition request completes
+ */
+void CT_LbsClientStep_MultiReq::GetLastKnownPositionCallback(TRequestStatus& aStatus)
+/**
+ * Called when NotifyModuleStatusEvent completes
+ */
+ {
+ TInt testCaseId;
+
+ if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
+ {
+ switch (testCaseId)
+ {
+ case 01: // multiple requests of different types
+ {
+ if(KErrNone == aStatus.Int())
+ {
+ switch(iState)
+ {
+ case EStateUnknown:
+ {
+ iState = EStateLastKnownPositionComplete;
+ }
+ break;
+
+ case EStateLastNotifyPositionUpdateComplete:
+ {
+ iState = EStateDone;
+ AsyncTidyUp();
+ // note: we'll now drop back into the main test step
+ }
+ break;
+
+ case EStateLastKnownPositionComplete:
+ case EStateDone :
+ // fall through
+ default:
+ {
+ User::Panic(KLbsClientStepMultiReq, KErrUnknown);
+ }
+ break;
+
+ }
+ }
+ else
+ {
+ INFO_PRINTF2(_L("NotifyModuleStatusEvent completed. Status =%d"), aStatus.Int());
+ SetTestStepResult(EFail);
+ AsyncTidyUp();
+ }
+
+ }// end case 01
+ break;
+ case 02: // NotifyPositionUpdate then GetLKP, latter cancelled
+ {
+ switch(iState)
+ {
+ case EStateUnknown:
+ {
+ iState = EStateLastKnownPositionComplete;
+ TInt err = aStatus.Int();
+ switch(err)
+ {
+ case KErrNone:
+ {
+ INFO_PRINTF1(_L("MultiReq test: Last Known Position request completed successfully"));
+ }
+ break;
+ case KErrCancel:
+ {
+ INFO_PRINTF1(_L("MultiReq test: Last Known Position request completed with KErrCancel"));
+ }
+ break;
+ case KErrUnknown:
+ {
+ INFO_PRINTF1(_L("MultiReq test: Last Known Position request completed with KErrUnknown"));
+ }
+ break;
+ default:
+ {
+
+ SetTestStepResult(EFail);
+ AsyncTidyUp();
+ }
+ break;
+ }
+ }
+ break;
+
+ case EStateLastNotifyPositionUpdateComplete:
+ {
+ iState = EStateDone;
+ TInt err = aStatus.Int();
+ if(KErrNone != err)
+ {
+ SetTestStepResult(EFail);
+ }
+ AsyncTidyUp();
+ }
+ break;
+
+ case EStateLastKnownPositionComplete:
+ case EStateDone :
+ // fall through
+ default:
+ {
+ User::Panic(KLbsClientStepMultiReq, KErrUnknown);
+ }
+ }// end switch(iState)
+ }// end case 2
+ break;
+
+ default:
+ {
+ User::Panic(KLbsClientStepMultiReq, KErrUnknown);
+ }
+ break;
+ }
+ }
+ }
+
+
+/**
+ * tidy up everything
+ */
+void CT_LbsClientStep_MultiReq::AsyncTidyUp()
+ {
+ if ( iTimer->IsActive() )
+ {
+ iTimer->Cancel();
+ }
+ // Cancel any outstanding requests (to be tested):
+ if(iNotifyPosUpdateAO->IsActive())
+ {
+ iNotifyPosUpdateAO->Cancel();
+ }
+ if(iGetLastKnownPosAO->IsActive())
+ {
+ iGetLastKnownPosAO->Cancel();
+ }
+ CActiveScheduler::Stop();
+ }
+
+
+/**
+ * Callback function - called if timer fires (requests did not all complete in time)
+ */
+static TInt TimerCallback(TAny* aPointer)
+ {
+ //the timer expired and we have not got the responses to our lbs requests
+ static_cast<CT_LbsClientStep_MultiReq*>(aPointer)->INFO_PRINTF1(_L(">>TEST FAILED: timer fired"));
+ static_cast<CT_LbsClientStep_MultiReq*>(aPointer)->AsyncTidyUp();
+ static_cast<CT_LbsClientStep_MultiReq*>(aPointer)->SetTestStepResult(EFail);
+
+ return KErrNone;
+ }
+
+/**
+ * @return - TVerdict code
+ * Override of base class pure virtual
+ * Our implementation only gets called if the base class doTestStepPreambleL() did
+ * not leave. That being the case, the current test result value will be EPass.
+ */
+TVerdict CT_LbsClientStep_MultiReq::doTestStepL()
+ {
+ // Generic test step used to test the LBS Client Notify position update API.
+ INFO_PRINTF1(_L(">>CT_LbsClientStep_MultiReq::doTestStepL()"));
+
+ if (TestStepResult()==EPass)
+ {
+ // Connect to self locate server.
+ User::LeaveIfError(iServer.Connect());
+ CleanupClosePushL(iServer);
+
+ TInt testCaseId;
+ if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
+ {
+ switch (testCaseId)
+ {
+ case 01: // multiple requests of different types
+ {
+ // Open positioner.
+ User::LeaveIfError(iPositioner.Open(iServer));
+ CleanupClosePushL(iPositioner);
+
+ // Carry out a notify update to ensure last known cache is filled (note: this blocks!)
+ TPositionInfo notifyPosInfo;
+ User::LeaveIfError(DoNotifyUpdateL(notifyPosInfo));
+
+ // Create 2 posinfos and store in our shared array for later verification.
+ RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
+ TPositionInfo* posInfoLastKnown = new(ELeave) TPositionInfo();
+ TPositionInfo* posInfoNotifyUpd = new(ELeave) TPositionInfo();
+
+ T_LbsUtils utils;
+ utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
+
+ // these get deleted by the base class destructor
+ posInfoArr.Append(posInfoLastKnown);
+ posInfoArr.Append(posInfoNotifyUpd);
+
+ // Start GetLastKnownPosition request:
+ iGetLastKnownPosAO = CT_LbsClientGetLastKnownPosAO::NewL(*this);
+
+ iGetLastKnownPosAO->GetLastKnownPosL(iPositioner, *posInfoLastKnown);
+
+ // Start NotifyPositionUpdate request:
+ iNotifyPosUpdateAO = CT_LbsClientNotifyPosUpdAO::NewL(*this);
+
+ iNotifyPosUpdateAO->NotifyPosUpdateL(iPositioner, *posInfoNotifyUpd);
+
+ // Start a timer to make sure neither of above times out:
+ iTimer = CPeriodic::New(CActive::EPriorityStandard);
+ TCallBack callbackFunction = TCallBack(TimerCallback, this);
+ iTimer->Start( delay10Seconds, 0, callbackFunction);
+
+ // can start the scheduler now as there are async requests issued
+ CActiveScheduler::Start();
+
+ // All requests have now completed (and scheduler stopped)
+
+ CleanupStack::PopAndDestroy(&iPositioner);
+ } // end case 1
+ break;
+
+ case 02: // cancel one of two outstanding requests
+ {
+ // Open positioner.
+ User::LeaveIfError(iPositioner.Open(iServer));
+ CleanupClosePushL(iPositioner);
+
+ // Create a posinfo and store in our shared array for later verification.
+ RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
+ TPositionInfo* posInfoNotifyUpd = new(ELeave) TPositionInfo();
+
+ T_LbsUtils utils;
+ utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
+
+ // this gets deleted by the base class destructor:
+ posInfoArr.Append(posInfoNotifyUpd);
+
+ // Start NotifyPositionUpdate request:
+ iNotifyPosUpdateAO = CT_LbsClientNotifyPosUpdAO::NewL(*this);
+
+ iNotifyPosUpdateAO->NotifyPosUpdateL(iPositioner, *posInfoNotifyUpd);
+
+ // Start a GetLastKnownPosition:
+ // don't put in verify array as this may be cancelled:
+ iTempPosInfo = new(ELeave) TPositionInfo();
+
+ iGetLastKnownPosAO = CT_LbsClientGetLastKnownPosAO::NewL(*this);
+
+ iGetLastKnownPosAO->GetLastKnownPosL(iPositioner, *iTempPosInfo);
+
+ // cancel the last known position. Note that we do this directly, NOT by calling the AO's cancel()
+ // so that the AO's RunL(), and therefore our callback, will be called and we can check the result
+ TInt err;
+ err = iPositioner.CancelRequest(EPositionerGetLastKnownPosition);
+ if(KErrNotFound != err)
+ {
+ SetTestStepResult(EFail);
+ }
+
+ // Start a timer to make sure neither of above times out:
+ iTimer = CPeriodic::New(CActive::EPriorityStandard);
+ TCallBack callbackFunction = TCallBack(TimerCallback, this);
+
+ //
+ //
+ // NB - THIS VALUE WAS 10 SEC AND THE TIMER EXPIRED, CAUSING THE TEST
+ // TO FAIL. NEED TO FIND OUT WHY THIS VALUE IS OK BUT THAT ONE WAS NOT.
+ // PUT BACK TEMPORARILY TO GET RID OF REGRESSION FAILURE
+ //
+ iTimer->Start( 22000000, 0, callbackFunction);
+
+ // can start the scheduler now as there are async requests issued
+ CActiveScheduler::Start();
+
+ // All requests have now completed
+
+ CleanupStack::PopAndDestroy(&iPositioner);
+ }
+ break;
+
+ default:
+ {
+ User::Leave(KErrArgument);
+ }
+ }// end switch
+ }//end if GetIntFromConfig
+
+ CleanupStack::PopAndDestroy(&iServer);
+
+ } // end if TestStepResult
+
+ INFO_PRINTF1(_L("<<CT_LbsClientStep_MultiReq::doTestStepL()"));
+
+ return TestStepResult();
+ }