// 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:

// CCommsdat100Step

// CCommsdat101Step

// CCommsdat102Step

// CCommsdat103Step

// CCommsdat104Step

// CCommsdat105Step

// 

//

/**

 @file commsdatValidationTests.cpp

*/

#include "commsdatValidationTests.h"

#include "CommsDatInternalDefs.h"

#include "Te_commsdatSuiteDefs.h"

#include <e32test.h>

#include <commsdat_partner.h>

#include <commsdattypesv1_1_partner.h>

#include <commsdattypeinfov1_1_internal.h>

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

namespace

{

TBool CheckConnPrefValidation(CommsDat::CMDBSession* aCDSession_v11, 

							  CommsDat::CMDBSession* aCDSession_vLatest)

	{

	TBool result = EFalse;

	CCDConnectionPrefsRecord* connPrefRec1 = static_cast<CCDConnectionPrefsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord));

    CleanupStack::PushL(connPrefRec1);

    //for the mapped APPriorityselPol field

    CMDBRecordLink<CCDAccessPointRecord>* apPrioritySelPolField = new(ELeave)CMDBRecordLink<CCDAccessPointRecord>();

    CleanupStack::PushL(apPrioritySelPolField);

    //the connPref records are mapped in the last APPrioritySelPol record (from the meshpreface.cfg)

    apPrioritySelPolField->SetRecordId(254);

    connPrefRec1->SetRecordId(1);

    connPrefRec1->LoadL(*aCDSession_v11);

    TInt rank = connPrefRec1->iRanking; 

    switch (rank)

    	{

    	case 1:

    		{

    		//rank 1 is mapped into the iAP1 field

    		apPrioritySelPolField->SetElementId(apPrioritySelPolField->ElementId() | KCDTIdAp1);

    		break;

    		}

    	case 2:

    		{

    		//rank 2 is mapped into the iAP2 field

    		apPrioritySelPolField->SetElementId(apPrioritySelPolField->ElementId() | KCDTIdAp2);

    		break;

    		}

    	default:

    		User::Leave(KErrNotFound);

    	}

    apPrioritySelPolField->LoadL(*aCDSession_vLatest);

    //at this point we know the elementId of the generated IPProto level AP which links aganst

    //the link level AP through its' CustomSelectionPolicy field. The value of this field in the

    //given IPProto AP must be the same as the recordID of the linked IAP record from the ConnPref

    //record.

    //so let's read the customSelectionPolicy field from the IPProto AP

    CMDBField<TInt>* custSelPolField = new(ELeave)CMDBField<TInt>(KCDTIdCustomSelectionPolicy);

    CleanupStack::PushL(custSelPolField);

    custSelPolField->SetRecordId((*apPrioritySelPolField & KCDMaskShowRecordId) >> 8);

    custSelPolField->LoadL(*aCDSession_vLatest);

    if (connPrefRec1->iDefaultIAP == *custSelPolField)

    	{

    	result = ETrue;

    	}

    CleanupStack::PopAndDestroy(custSelPolField);

    CleanupStack::PopAndDestroy(apPrioritySelPolField);

    CleanupStack::PopAndDestroy(connPrefRec1);

    return result;

	}

TInt GetAPNumberL(const TInt aTierValaue, CommsDat::CMDBSession* aCDSession_vLatest)

	{

	CMDBRecordSet<CCDAccessPointRecord>* ipprotoAPs = new(ELeave)CMDBRecordSet<CCDAccessPointRecord>(KCDTIdAccessPointRecord);

	CleanupStack::PushL(ipprotoAPs);

	CCDAccessPointRecord* primedIPProtoAP = static_cast<CCDAccessPointRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdAccessPointRecord));

	CleanupStack::PushL(primedIPProtoAP);

	primedIPProtoAP->iTier = aTierValaue;

	ipprotoAPs->iRecords.AppendL(primedIPProtoAP);

	//the ownership of the primed record is now at the recordset

	CleanupStack::Pop(primedIPProtoAP);

	ipprotoAPs->FindL(*aCDSession_vLatest);

	TInt apNum = ipprotoAPs->iRecords.Count();

	CleanupStack::PopAndDestroy(ipprotoAPs);

	return apNum;

	}

}

#endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

void CConnectionPrefValidationTestBase::deleteAllL()

	{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CMDBRecordSet<CCDConnectionPrefsRecord> *recordSet1 = new (ELeave) CMDBRecordSet<CCDConnectionPrefsRecord>(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(recordSet1);

	TRAPD(loadErr, recordSet1->LoadL(*cmdbSession));

	if(loadErr == KErrNone)

		{

		recordSet1->DeleteL(*cmdbSession);

		}

	CleanupStack::PopAndDestroy(recordSet1);

	CMDBRecordSet<CCDIAPRecord> *recordSet2 = new(ELeave) CMDBRecordSet<CCDIAPRecord>(KCDTIdIAPRecord);

	CleanupStack::PushL(recordSet2);

	TRAP(loadErr, recordSet2->LoadL(*cmdbSession));

	if(loadErr == KErrNone)

		{

		recordSet2->DeleteL(*cmdbSession);

		}

	CleanupStack::PopAndDestroy(recordSet2);

	CleanupStack::PopAndDestroy(cmdbSession);

	}

TVerdict CConnectionPrefValidationTestBase::doTestStepPreambleL()

	{

	SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("I am in doTestStepPreambleL() and deleting all connection preferences record"));

	deleteAllL();

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CConnectionPrefValidationTestBase::doTestStepPostambleL()

	{

	deleteAllL();

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat100Step::CCommsdat100Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat100Step);                                                                                           

	}

TVerdict CCommsdat100Step::doTestStepL()

/**

 * @return - TVerdict code

 * The IAP record, conn pref record refers to, has to have a valid id, hence less 

 * than KCDMaxRecords.

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat100Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDConnectionPrefsRecord *cpRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord);

	cpRecord->SetRecordId(KConnPrefRecordId );

	cpRecord->iDefaultIAP = KCDMaxRecords;

	TRAPD(storeErr, cpRecord->StoreL(*cmdbSession));

	if(storeErr == KErrNotFound)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(cpRecord);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat101Step::CCommsdat101Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat101Step);                                                                                           

	}

TVerdict CCommsdat101Step::doTestStepL()

/**

 * @return - TVerdict code

 * The ranking of conn pref record must be eiher 1 or 2, testing with an invalid value

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat101Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDConnectionPrefsRecord *cpRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord);

	cpRecord->SetRecordId(KConnPrefRecordId);

	cpRecord->iDefaultIAP = 1; // An arbitrary but still valid IAP record id

	cpRecord->iRanking = 3;    // Invalid value, should cause KErrOverflow

	TRAPD(storeErr, cpRecord->StoreL(*cmdbSession));

	INFO_PRINTF2(_L("store returns %d"), storeErr);

	if(storeErr == KErrOverflow)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(cpRecord);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat102Step::CCommsdat102Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat102Step);                                                                                           

	}

TVerdict CCommsdat102Step::doTestStepL()

/**

 * @return - TVerdict code

 * Conn pref records with a rank of 2 are not permitted to be incoming

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat102Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDConnectionPrefsRecord *cpRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord);

	cpRecord->SetRecordId(KConnPrefRecordId);

	cpRecord->iDefaultIAP = 1;  // An arbitrary, but valiad IAP record id

	cpRecord->iRanking = 2;     // A invalid ranking for incoming connection

	cpRecord->iDirection = ECommDbConnectionDirectionIncoming;

	TRAPD(storeErr, cpRecord->StoreL(*cmdbSession));

	if(storeErr == KErrNotSupported)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(cpRecord);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat103Step::CCommsdat103Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat103Step);                                                                                           

	}

const TInt KRanking = 1; 

TVerdict CCommsdat103Step::doTestStepL()

/**

 * @return - TVerdict code

 * Two conn pref records with the same ranking are not allowed

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat103Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDIAPRecord *iapRecord = (CCDIAPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord);

	CleanupStack::PushL(iapRecord); 

	//Insert an IAP record; which will be referred by conn pref records

	iapRecord->SetRecordId(KIAPRecordId); 

	iapRecord->iServiceType.SetMaxLengthL(KMaxTextLength);

	iapRecord->iServiceType= TPtrC(DIAL_OUT_ISP);

	iapRecord->iService=1;

	iapRecord->iBearerType.SetMaxLengthL(KMaxTextLength);

	iapRecord->iBearerType=TPtrC(LAN_BEARER);

	iapRecord->iBearer=1;

	iapRecord->StoreL(*cmdbSession);

	CleanupStack::PopAndDestroy(iapRecord);

	CCDConnectionPrefsRecord *cpRecord1 = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord1);

	cpRecord1->SetRecordId(KConnPrefRecordId);

	cpRecord1->iDefaultIAP = KIAPRecordId;  //A valid IAP record id 

	cpRecord1->iRanking = KRanking;         //A valid ranking

	cpRecord1->iDirection = ECommDbConnectionDirectionOutgoing;  //A valid direction

	TRAPD(storeErr1, cpRecord1->StoreL(*cmdbSession));  // Should raise KErrNone

	INFO_PRINTF2(_L("first store returns %d"), storeErr1);

	CCDConnectionPrefsRecord *cpRecord2 = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord2);

	cpRecord2->SetRecordId(KConnPrefRecordId + 1);//Just another conn pref record

	cpRecord2->iDefaultIAP = KIAPRecordId ;       //A valid IAP record id

	cpRecord2->iRanking = KRanking;               //Same ranking with above one; should cause KErrAlreadyExists

	cpRecord2->iDirection = ECommDbConnectionDirectionOutgoing; // A valid direction

	TRAPD(storeErr2, cpRecord2->StoreL(*cmdbSession));// Should raise KErrAlreadyExists

	INFO_PRINTF2(_L("second store returns %d"), storeErr2);

	if(storeErr1 == KErrNone && storeErr2 == KErrAlreadyExists)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(cpRecord2);

	CleanupStack::PopAndDestroy(cpRecord1);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat104Step::CCommsdat104Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat104Step);                                                                                           

	}

TVerdict CCommsdat104Step::doTestStepL()

/**

 * @return - TVerdict code

 * An outgoing IAP; cannot be referred as incoming

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat104Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDIAPRecord *iapRecord = (CCDIAPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord);

	CleanupStack::PushL(iapRecord); 

	//Insert an outgoing IAP record

	iapRecord->SetRecordId(KIAPRecordId);

	iapRecord->iServiceType.SetMaxLengthL(KMaxTextLength);

	iapRecord->iServiceType= TPtrC(DIAL_OUT_ISP);  // Outgoing IAP

	TRAPD(storeErr1, iapRecord->StoreL(*cmdbSession)); //Should return KErrNone

	CCDConnectionPrefsRecord *cpRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord);

	cpRecord->SetRecordId(KConnPrefRecordId);

	cpRecord->iRanking = 1;    //A valid ranking

	cpRecord->iDirection = ECommDbConnectionDirectionIncoming; //Should cause KErrArgument

	cpRecord->iDefaultIAP = KIAPRecordId;  //The IAP record inserted above

	cpRecord->iBearerSet = KCommDbBearerCSD;  //Type of bearer

	TRAPD(storeErr2, cpRecord->StoreL(*cmdbSession)); //Should return KErrArgument

	if(storeErr1 == KErrNone && storeErr2 == KErrArgument)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(cpRecord);

	CleanupStack::PopAndDestroy(iapRecord);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat105Step::CCommsdat105Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat105Step);                                                                                           

	}

TVerdict CCommsdat105Step::doTestStepL()

/**

 * @return - TVerdict code

 * A valid combination: an outgoing IAP is referred with an outgoing direction 

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat105Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDIAPRecord *iapRecord = (CCDIAPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord);

	CleanupStack::PushL(iapRecord);

	// An outgoing IAP record is inserted

	iapRecord->SetRecordId(KIAPRecordId);

	iapRecord->iServiceType.SetMaxLengthL(KMaxTextLength);

	iapRecord->iServiceType= TPtrC(DIAL_OUT_ISP);

	iapRecord->iService=1;

	iapRecord->iBearerType.SetMaxLengthL(KMaxTextLength);

	iapRecord->iBearerType=TPtrC(LAN_BEARER);

	iapRecord->iBearer=1;

	TRAPD(storeErr1, iapRecord->StoreL(*cmdbSession)); //Should return KErrNone

	CCDConnectionPrefsRecord *cpRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord);

	cpRecord->SetRecordId(KConnPrefRecordId);

	cpRecord->iRanking = 1;     // A valid ranking

	cpRecord->iDirection = ECommDbConnectionDirectionOutgoing;  //A valid direction

	cpRecord->iDefaultIAP = KIAPRecordId;  //IAP record inserted above

	cpRecord->iBearerSet = KCommDbBearerLAN; // A valid bearer type

	TRAPD(storeErr2, cpRecord->StoreL(*cmdbSession)); //Should return KErrNone

	if(storeErr1 == KErrNone && storeErr2 == KErrNone)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(cpRecord);

	CleanupStack::PopAndDestroy(iapRecord);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

//----------------------------------------------------------------------------------------------------------------

CCommsdat106Step::CCommsdat106Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat106Step);                                                                                           

	}

TVerdict CCommsdat106Step::doTestStepL()

/**

 * @return - TVerdict code

 Test whether iDefaultIAP accepts zero as a valid value, since phones get shipped without any predefined IAPs

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing validation for connection preferences in CCommsdat106Step::doTestStepL() "));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession *cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession); 

	CCDConnectionPrefsRecord *cpRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	CleanupStack::PushL(cpRecord);