diff -r 000000000000 -r dfb7c4ff071f datacommsserver/networkcontroller/ts_netcon/TestBases.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/networkcontroller/ts_netcon/TestBases.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,922 @@ +// Copyright (c) 2002-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 "TestBases.h" +#include "CStubbedAgent.h" +#include "NetConError.h" +#include "NetConLog.h" +#include "CTelBearer.h" +#include "CNetConDlgProcessor.h" +// +// // +// Implementation of class CControllerTestBase // +// // +// +CControllerTestBase::~CControllerTestBase() + {} + +/** + Called when an unimplemented function is called in a test case - + this is primarily intended as a debugging conveniance + */ +void CControllerTestBase::Unimplemented() const + { + User::Invariant(); + } + +CCommsDbAccess* CControllerTestBase::NewDatabaseL() + { + /* Construct a tear-off CCommsDbAccess interface */ + CCommsDbAccess* database = CCommsDbAccess::NewL( this ); + return database; + } + +CNetConDlgProcessor* CControllerTestBase::NewDialogProcessorL() + { + /* + Derived classes which implement the DialogProcessor + functionality can over-ride this + */ + Unimplemented(); + return NULL; + } + +CControllerTestBase::CControllerTestBase() + { + } + +// +// from MCommsDbAccess +TInt CControllerTestBase::GetConnectionAttempts() + { + + Unimplemented(); + return 0; + } + +void CControllerTestBase::GetCurrentSettingsL(TConnectionSettings&, TCommDbConnectionDirection, TUint32) + { + + Unimplemented(); + } + +void CControllerTestBase::SetCurrentSettingsL(const TConnectionSettings&) + { + + Unimplemented(); + } + +void CControllerTestBase::SetOverridesL(CCommDbOverrideSettings*) + { + + Unimplemented(); + } + +void CControllerTestBase::GetPreferedIapL(TUint32& /*aIapId*/, TCommDbConnectionDirection /*aDirection*/, TUint32 /*aRank*/) + { + + Unimplemented(); + } + +void CControllerTestBase::SetPreferedIapL(TUint32& /*aIapId*/, TCommDbConnectionDirection /*aDirection*/, TUint32 /*aRank*/) + { + + Unimplemented(); + } + + +TBool CControllerTestBase::DoesIapExistL(TUint32 /*aIapId*/) + { + + return ETrue; + } + +void CControllerTestBase::GetFirstValidIapL(TUint32& aIapId) + { + + aIapId = 1; + } + +TBool CControllerTestBase::IsTelNumLengthZeroForRasConnectionL(TConnectionSettings&) + { + + Unimplemented(); + return EFalse; + } + +void CControllerTestBase::GetServiceSettingsL(TConnectionSettings&) + { + + Unimplemented(); + } + +RMobilePhone::TMobilePhoneNetworkMode CControllerTestBase::NetworkMode() const + { + + Unimplemented(); + return RMobilePhone::ENetworkModeUnknown; + } + +void CControllerTestBase::SetNetworkMode(RMobilePhone::TMobilePhoneNetworkMode) + { + + Unimplemented(); + } + +void CControllerTestBase::GetDesL(const TDesC&, const TDesC&, TDes16&) + { + + Unimplemented(); + } + +void CControllerTestBase::GetIntL(const TDesC& aTable, const TDesC& aField, TUint32& aValue) + { + if( aTable == TPtrC(MODEM_BEARER) && aField == TPtrC(MODEM_MIN_SIGNAL_LEVEL) ) + { + // Forward to virtual member + GetMinSigStrengthL( aValue ); + } + else + { + Unimplemented(); + } + } + +void CControllerTestBase::GetTsyNameL( TDes& /*aTsyName*/ ) + { + Unimplemented(); + } + +void CControllerTestBase::GetBearerAvailabilityTsyNameL(TDes& aTsyName) + { + GetTsyNameL( aTsyName ); + } + +void CControllerTestBase::GetMinSigStrengthL(TUint32&) + { + Unimplemented(); + } + +void CControllerTestBase::RequestNotificationOfServiceChangeL(MServiceChangeObserver* /*aObserver*/) + { + } + +void CControllerTestBase::CancelRequestNotificationOfServiceChange(MServiceChangeObserver* /*aObserver*/) + { + } + +// +// from MNetConEnv +void CControllerTestBase::RequestComplete(const CSelectionRequest*, TInt) + { + + Unimplemented(); + } + +void CControllerTestBase::RequestComplete(const CReconnectRequest*, TInt) + { + + Unimplemented(); + } + +const HBufC* CControllerTestBase::ImplicitConnectionAgentName() const + { + + Unimplemented(); + return NULL; + } + +const TConnPref& CControllerTestBase::ImplicitConnectionPrefs() const + { + Unimplemented(); + return iImplicitConnPref; + } + +TInt CControllerTestBase::FindExistingAgentForSelection(CNifAgentBase*&, CCommsDbAccess*) const + { + + Unimplemented(); + return 0; + } + +void CControllerTestBase::CheckBearerAvailability(TBool) + { + + Unimplemented(); + } + +TInt CControllerTestBase::RequestSecondPhaseAvailability() + { + + Unimplemented(); + return 0; + } + +void CControllerTestBase::AddAgentToNetworkL(CNifAgentBase*, TUint32) + { + + Unimplemented(); + } + +void CControllerTestBase::CancelBearerAvailabilityCheck() + { + } + +void CControllerTestBase::Close() + { + } + +TBool CControllerTestBase::IsShowingHiddenRecords() + { + Unimplemented(); + return EFalse; + } + +void CControllerTestBase::SetCommPortL( const RCall::TCommPort& ) + { + Unimplemented(); + } + +void CControllerTestBase::GetServiceTypeL( TDes& ) + { + Unimplemented(); + } + +TInt CControllerTestBase::ReadInt(const TDesC& /*aField*/, TUint32& /*aValue*/) + { + Unimplemented(); + return 0; + } +TInt CControllerTestBase::ReadBool(const TDesC& /*aField*/, TBool& /*aValue*/) + { + Unimplemented(); + return 0; + } +TInt CControllerTestBase::ReadDes(const TDesC& /*aField*/, TDes8& /*aValue*/) + { + Unimplemented(); + return 0; + } +TInt CControllerTestBase::ReadDes(const TDesC& /*aField*/, TDes16& /*aValue*/) + { + Unimplemented(); + return 0; + } +HBufC* CControllerTestBase::ReadLongDesLC(const TDesC& /*aField*/) + { + Unimplemented(); + return 0; + } + +void CControllerTestBase::GetDesL(const TDesC& /*aTable*/, const TDesC& /*aField*/, TDes8& /*aValue*/) + { + Unimplemented(); + } + +void CControllerTestBase::GetBoolL(const TDesC& /*aTable*/, const TDesC& /*aField*/, TBool& /*aValue*/) + { + Unimplemented(); + } + +HBufC* CControllerTestBase::GetLongDesLC(const TDesC& /*aTable*/, const TDesC& /*aField*/) + { + Unimplemented(); + return 0; + } +TInt CControllerTestBase::GetLengthOfLongDesL(const TDesC& /*aTable*/, const TDesC& /*aField*/) + { + Unimplemented(); + return 0; + } + +void CControllerTestBase::GetGlobalL(const TDesC& /*aName*/,TUint32& /*aVal*/ ) + { + Unimplemented(); + } + +CCommsDbAccess::CCommsDbAccessModemTable* CControllerTestBase::ModemTable() + { + Unimplemented(); + return 0; + } + +TUint32 CControllerTestBase::LocationId() const + { + Unimplemented(); + return 0; + } + +TCommDbConnectionDirection CControllerTestBase::GetConnectionDirection() const + { + Unimplemented(); + return ECommDbConnectionDirectionUnknown; + } + +void CControllerTestBase::GetAgentExtL(const TDesC& /*aServiceType*/, TDes& /*aAgentExt*/ ) + { + Unimplemented(); + } + +void CControllerTestBase::GetAuthParamsL( TBool&, TDes&, TDes& ) + { + Unimplemented(); + } + +TInt CControllerTestBase::WriteDes(const TDesC& /*aField*/, const TDesC16& /*aValue*/) +/** +Writes from the NIF are currently not supported... +*/ + { + return KErrNotSupported; + } + +TInt CControllerTestBase::WriteDes(const TDesC& /*aField*/, const TDesC8& /*aValue*/) +/** +Writes from the NIF are currently not supported... +*/ + { + return KErrNotSupported; + } + + +TInt CControllerTestBase::WriteBool(const TDesC& /*aField*/, TBool /*aValue*/) +/** +Writes from the NIF are currently not supported... +*/ + { + return KErrNotSupported; + } + +TInt CControllerTestBase::WriteInt(const TDesC& /*aField*/, TUint32 /*aValue*/) +/** +Writes from the NIF are currently not supported... +*/ + { + return KErrNotSupported; + } + +TInt CControllerTestBase::DoCheckReadCapability( const TDesC& /*aField*/, const RMessagePtr2* /*aMessage*/ ) + { + return KErrNone; + } + +TInt CControllerTestBase::DoCheckWriteCapability( const TDesC& /*aField*/, const RMessagePtr2* /*aMessage*/ ) + { + return KErrNone; + } + +// +// +// + + +// +// // +// Implementation of class CNetConRequestTestBase // +// // +// +// +// +// + +CNetConRequestTestBase::CNetConRequestTestBase() + : iExpectedError(KErrNone), iAvailableBearers(ECommDbBearerUnknown), iSecondPhaseAvailability(ETrue), + iDialogBoxPref(ECommDbDialogPrefUnknown), iDialogBoxError(KErrNone) + {} + +void CNetConRequestTestBase::ConstructL() + { + + TCallBack bearerCallBack(BearerCb, this); + iBearerCb = new(ELeave) CAsyncCallBack(bearerCallBack, CActive::EPriorityStandard); + + TCallBack dialogCallBack(DialogCb, this); + iDialogCb = new(ELeave) CAsyncCallBack(dialogCallBack, CActive::EPriorityStandard); + } + +CNetConRequestTestBase::~CNetConRequestTestBase() + { + + delete iRequest; + + delete iAgent; + + delete iDialogCb; + + delete iBearerCb; + } + +CNetConDlgProcessor* CNetConRequestTestBase::NewDialogProcessorL() + { + // Construct a tear-off interface + CNetConDlgProcessor *processor = CNetConDlgProcessor::NewL( this, EFalse ); + return processor; + } + +TInt CNetConRequestTestBase::RequestSecondPhaseAvailability() + { + + if (iSecondPhaseAvailability) + { + return KErrNone; + } + else + { + return KErrNetConInadequateSignalStrengh; + } + } + +TInt CNetConRequestTestBase::BearerCb(TAny* aThisPtr) + { + CNetConRequestTestBase* self = static_cast(aThisPtr); + self->BearerCbComplete(); + return KErrNone; + } + +void CNetConRequestTestBase::BearerCbComplete() + { + + iRequest->SetAvailableBearers(iAvailableBearers); + iAvailableBearers = ECommDbBearerUnknown; + } + +TInt CNetConRequestTestBase::DialogCb(TAny* aThisPtr) + { + CNetConRequestTestBase* self = static_cast(aThisPtr); + self->DialogCbComplete(); + return KErrNone; + } + +void CNetConRequestTestBase::StartTestL() + { + + iRequest->StartRequest(); + } + +void CNetConRequestTestBase::GetDefaultTestSettings(TConnectionSettings& aSettings) + { + + aSettings.iRank = 1; + aSettings.iDirection = ECommDbConnectionDirectionOutgoing; + aSettings.iDialogPref = iDialogBoxPref; + aSettings.iBearerSet = KCommDbBearerCSD; + aSettings.iIAPId = 1; + aSettings.iServiceId = 1; + aSettings.iServiceType = TPtrC(DIAL_OUT_ISP); + aSettings.iBearerId = 2; + aSettings.iLocationId = 2; + aSettings.iChargeCardId = 0; + } + +// +// from MNetConDialogProcAccess +void CNetConRequestTestBase::SelectConnection(MDialogProcessorObserver&, const TConnectionPrefs&) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::SelectConnection(MDialogProcessorObserver&, const TConnectionPrefs&, TInt) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::SelectModemAndLocation(MDialogProcessorObserver&) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::WarnNewConnection(MDialogProcessorObserver&, const TConnectionPrefs&, const TDesC*, const TIspConnectionNames*, TInt) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::Reconnect(MDialogProcessorObserver&) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::CancelEverything() + { + + Unimplemented(); + } + +// +// from MNetworkControllerObserver +void CNetConRequestTestBase::SelectComplete(const TDesC&) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::SelectComplete(TInt) + { + + Unimplemented(); + } + +void CNetConRequestTestBase::ReconnectComplete(TInt) + { + + Unimplemented(); + } +// +// +// + + +// +// // +// Implementation of class CNetConReconnectRequestTestBase // +// // +// +// +// +// +CNetConReconnectRequestTestBase::CNetConReconnectRequestTestBase() + {} + +void CNetConReconnectRequestTestBase::ConstructL() + { + + CNetConRequestTestBase::ConstructL(); + + iAgent = new(ELeave) CStubbedAgent(); + + TConnectionSettings settings; + GetDefaultTestSettings(settings); + iAgent->SetConnectionSettingsL(settings); + + iRequest = CReconnectRequest::NewL(this, this, iAgent, NULL); + } + +CNetConReconnectRequestTestBase::~CNetConReconnectRequestTestBase() + { } + +void CNetConReconnectRequestTestBase::CheckBearerAvailability(TBool aIsReconnect) + { + + ASSERT(aIsReconnect); + (void)aIsReconnect; + + iBearerCb->CallBack(); + } + +void CNetConReconnectRequestTestBase::Reconnect(MDialogProcessorObserver& aObserver) + { + + ASSERT(&aObserver == iRequest); + + iDialogBoxObserver = &aObserver; + iDialogCb->CallBack(); + } + +void CNetConReconnectRequestTestBase::DialogCbComplete() + { + + iDialogBoxObserver->MDPOReconnectComplete(iDialogBoxError); + iDialogBoxObserver = NULL; + iDialogBoxError = KErrNone; + } + +void CNetConReconnectRequestTestBase::RequestComplete(const CReconnectRequest* aRequest, TInt aError) + { + + ASSERT(static_cast(aRequest) == iRequest); + (void)aRequest; + + if(aError == iExpectedError) + CompleteTest(MNetConTest::EPassed); + else + CompleteTest(MNetConTest::EFailed); + } +// +// +// + + +// +// // +// Implementation of class CNetConSelectionRequestTestBase // +// // +// +// +// +// +CNetConSelectionRequestTestBase::CNetConSelectionRequestTestBase() + :iConnectType(EConnStartExplicit), + iConnectionAttempt(1), + iLastConnectionError(KErrNone), + iNetworkId(0) + {} + +void CNetConSelectionRequestTestBase::ConstructL() + { + + CNetConRequestTestBase::ConstructL(); + + TCommDbConnPref prefs; + iRequest = CSelectionRequest::NewL(this, this, iConnectType, prefs, iConnectionAttempt, iLastConnectionError); + } + +CNetConSelectionRequestTestBase::~CNetConSelectionRequestTestBase() + { } + +TInt CNetConSelectionRequestTestBase::GetConnectionAttempts() + { + + return 2; + } + +void CNetConSelectionRequestTestBase::GetCurrentSettingsL(TConnectionSettings& aSettings, TCommDbConnectionDirection aDirection, TUint32 aRank) + { + + if(aRank!=(TUint32)iConnectionAttempt) + { + CompleteTest(MNetConTest::EFailed); + return; + } + + GetDefaultTestSettings(iSettings); + iSettings.iDirection = aDirection; + iSettings.iRank = aRank; + aSettings = iSettings; + } + +void CNetConSelectionRequestTestBase::SetCurrentSettingsL(const TConnectionSettings& aSettings) + { + + TBool settingsOk(ETrue); + + if (aSettings.iRank != iSettings.iRank) + settingsOk = EFalse; + + if (aSettings.iDirection != iSettings.iDirection) + settingsOk = EFalse; + + if (aSettings.iDialogPref != iSettings.iDialogPref) + settingsOk = EFalse; + + if (aSettings.iBearerSet != iSettings.iBearerSet) + settingsOk = EFalse; + + if (aSettings.iIAPId != iSettings.iIAPId) + settingsOk = EFalse; + + if (aSettings.iServiceId != iSettings.iServiceId) + settingsOk = EFalse; + + if (aSettings.iServiceType != iSettings.iServiceType) + settingsOk = EFalse; + + if (aSettings.iBearerId != iSettings.iBearerId) + settingsOk = EFalse; + + if (aSettings.iLocationId != iSettings.iLocationId) + settingsOk = EFalse; + + if (aSettings.iChargeCardId != iSettings.iChargeCardId) + settingsOk = EFalse; + + if(!settingsOk) + CompleteTest(MNetConTest::EFailed); + } + +void CNetConSelectionRequestTestBase::SetOverridesL(CCommDbOverrideSettings* aOverrides) + { + + if(aOverrides) + { + User::Invariant(); + } + } + +void CNetConSelectionRequestTestBase::GetPreferedIapL(TUint32& aIapId, TCommDbConnectionDirection /*aDirection*/, TUint32 /*aRank*/) + { + + // default to IAP 1 + aIapId = 1; + } + +void CNetConSelectionRequestTestBase::SetPreferedIapL(TUint32& /*aIapId*/, TCommDbConnectionDirection /*aDirection*/, TUint32 /*aRank*/) + { + // This should not get called as DoesIapExistL returns true + Unimplemented(); + } + + +TBool CNetConSelectionRequestTestBase::DoesIapExistL(TUint32 /*aIapId*/) + { + + return ETrue; + } + +TBool CNetConSelectionRequestTestBase::IsTelNumLengthZeroForRasConnectionL(TConnectionSettings&) + { + + return EFalse; + } + +void CNetConSelectionRequestTestBase::GetServiceSettingsL(TConnectionSettings& aSettings) + { + + aSettings.iServiceId = iSettings.iServiceId; + aSettings.iServiceType = iSettings.iServiceType; + } + +void CNetConSelectionRequestTestBase::GetDesL(const TDesC& aTable, const TDesC& aField, TDes16& aValue) + { + + if (aTable == TPtrC(IAP) && aField == TPtrC(COMMDB_NAME)) + { + _LIT(KIapName, "An Internet Access Point"); + aValue = KIapName(); + } + else if(aField == TPtrC(AGENT_NAME)) + { + _LIT(KAgentName, "StubbedAgent"); + aValue = KAgentName(); + } + else + { + CNetConRequestTestBase::GetDesL( aTable, aField, aValue ); + } + } + +void CNetConSelectionRequestTestBase::GetIntL(const TDesC& aTable, const TDesC& aField, TUint32& aValue) + { + + if(aTable == TPtrC(IAP) && aField == TPtrC(IAP_NETWORK)) + { + aValue = iNetworkId; + } + else + { + CNetConRequestTestBase::GetIntL( aTable, aField, aValue ); + } + } + +TInt CNetConSelectionRequestTestBase::FindExistingAgentForSelection(CNifAgentBase*&, CCommsDbAccess*) const + { + + return KErrNotFound; + } + +void CNetConSelectionRequestTestBase::CheckBearerAvailability(TBool aIsReconnect) + { + + ASSERT(!aIsReconnect); + (void)aIsReconnect; + + iBearerCb->CallBack(); + } + +void CNetConSelectionRequestTestBase::AddAgentToNetworkL(CNifAgentBase* aAgent, TUint32 aNetworkId) + { + + if(aNetworkId != iNetworkId || !aAgent) + { + CompleteTest(MNetConTest::EFailed); + return; + } + + ASSERT(!iAgent); + iAgent = aAgent; + + CleanupStack::Pop(); // CStubbedAgent allocated in Nif::CreateAgentL() + } + +void CNetConSelectionRequestTestBase::DialogCbComplete() + { + + Unimplemented(); + } + +void CNetConSelectionRequestTestBase::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs) + { + + SelectConnection(aObserver, aPrefs, KErrNone); + } + +void CNetConSelectionRequestTestBase::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs&, TInt aLastConnectionError) + { + + ASSERT(&aObserver == iRequest); + ASSERT(!iDialogBoxObserver); + + if(aLastConnectionError != iLastConnectionError) + { + CompleteTest(MNetConTest::EFailed); + return; + } + + iDialogBoxAction = ESelectConnection; + iDialogBoxObserver = &aObserver; + iDialogCb->CallBack(); + } + +void CNetConSelectionRequestTestBase::SelectModemAndLocation(MDialogProcessorObserver& aObserver) + { + + ASSERT(&aObserver == iRequest); + ASSERT(!iDialogBoxObserver); + + iDialogBoxAction = ESelectModemLocation; + iDialogBoxObserver = &aObserver; + iDialogCb->CallBack(); + } + +void CNetConSelectionRequestTestBase::WarnNewConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs&, const TDesC*, const TIspConnectionNames*, TInt aLastConnectionError) + { + + ASSERT(&aObserver == iRequest); + ASSERT(!iDialogBoxObserver); + + if(aLastConnectionError != iLastConnectionError) + { + CompleteTest(MNetConTest::EFailed); + return; + } + + iDialogBoxAction = EWarnNewConnection; + iDialogBoxObserver = &aObserver; + iDialogCb->CallBack(); + } + +void CNetConSelectionRequestTestBase::RequestComplete(const CSelectionRequest* aRequest, TInt aError) + { + + ASSERT(static_cast(aRequest) == iRequest); + (void)aRequest; + + if(aError == iExpectedError) + CompleteTest(MNetConTest::EPassed); + else + CompleteTest(MNetConTest::EFailed); + } +// +// +// + + +// +// // +// Implementation of class CNetConBearerTestBase // +// // +// +// +// +// +CNetConBearerTestBase::~CNetConBearerTestBase() + { + delete iTelBearer; + iTelBearer = 0; + delete iDatabase; + iDatabase = 0; + } + +CNetConBearerTestBase::CNetConBearerTestBase() + :iTelBearer(0), + iDatabase(0) + { + } + +void CNetConBearerTestBase::ConstructL() + { + ASSERT( !iDatabase ); + ASSERT( !iTelBearer ); + iTelBearer = CTelBearer::NewL( this ); + iDatabase = CCommsDbAccess::NewL(this); + } + +void CNetConBearerTestBase::BearerStateChange(CBearerBase*) + { + Unimplemented(); + } + +CCommsDbAccess *CNetConBearerTestBase::DbAccess() + { + ASSERT( iDatabase ); // in case someone forgot to call ConstructL from a derived class... + return iDatabase; + } +// +// +// +