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

// CCommsdat40Step

// CCommsdat41Step

// CCommsdat42Step

// CCommsdat43Step

// CCommsdat44Step

// CCommsdat45Step

// CCommsdat46Step

// CCommsdat47Step

// CCommsdat48Step

// CCommsdat49Step

// CCommsdat50Step

// CCommsdat51Step

// CCommsdat52Step

// CCommsdat53Step

// CCommsdat54Step

// CCommsdat55Step

// CCommsdat56Step

// CCommsdat57Step

// CCommsdat58Step

// CCommsdat59Step

// CCommsdat60Step

// CCommsdat61Step

// CCommsdat62Step

// CCommsdat63Step

// CCommsdat64Step

// CCommsdat65Step

// CCommsdat66Step

// CCommsdat67Step

// CCommsdat68Step

// CCommsdat70Step

// CCommsdat71Step

// CCommsdat72Step

// CCommsdat73Step

// 

//

/**

 @file commsdatDatabaseOperationsTests.cpp

*/

#include "commsdatDatabaseOperationsTests.h"

#include "Te_commsdatSuiteDefs.h"

#include <e32test.h>

#include <e32base.h>

#include <d32comm.h>

#include <commsdattypesv1_1_partner.h>

#include <commsdattypeinfov1_1_internal.h>

CCommsdat40Step::CCommsdat40Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat40Step);

	}

TVerdict CCommsdat40Step::doTestStepL()

/**

 * @return - TVerdict code

 * Setting field values and storing a new record

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Setting and getting field values - CCommsdat40Step::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);

	iapRecord->SetRecordId(KCDNewRecordRequest);

	TPtrC aValue(_L("TestName"));

    iapRecord->iRecordName.SetMaxLengthL(aValue.Length());

    iapRecord->iRecordName = aValue;

    TPtrC bPtr(static_cast<const TDesC&>(iapRecord->iRecordName));

    INFO_PRINTF2(_L("Set iRecordName to %S"), &bPtr);

	iapRecord->iNetworkWeighting = 10;

    TInt i = iapRecord->iNetworkWeighting;

	INFO_PRINTF2(_L("Set iNetworkWeighting to %d"), i);

	cmdbSession->OpenTransactionL();

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

	cmdbSession->CommitTransactionL();

	if(storeErr == KErrNone)

		{

		SetTestStepResult(EPass);	

		}

	CleanupStack::PopAndDestroy(iapRecord);

    CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

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

CCommsdat41Step::CCommsdat41Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat41Step);

	}

TVerdict CCommsdat41Step::doTestStepL()

/**

 * @return - TVerdict code

 * Finding a record; record should be inserted with CED te_commsdat_iap_table1

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("CCommsdat41Step::doTestStepL() in the file commsdat41Step.cpp"));

#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 = static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

	CleanupStack::PushL(iapRecord);

	iapRecord->iNetworkWeighting = 10;

    TBool found(EFalse);

	found = iapRecord->FindL(*cmdbSession);

    if (found)

    	{

        SetTestStepResult(EPass);	

    	}

    INFO_PRINTF2(_L("FindL returned %d, should be 1"), found);

    INFO_PRINTF2(_L("test result is %d"), TestStepResult());

    CleanupStack::PopAndDestroy(iapRecord);

    CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

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

CCommsdat42Step::CCommsdat42Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat42Step);

	}

TVerdict CCommsdat42Step::doTestStepL()

/**

 * @return - TVerdict code

 * Storing and finding record

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Storing and finding a record - CCommsdat42Step::doTestStepL() in the file commsdat42Step.cpp"));

#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);

	iapRecord->SetRecordId(KCDNewRecordRequest);

    iapRecord->iRecordName.SetMaxLengthL(20);

    iapRecord->iRecordName = _L("TestNameTemplate");

	iapRecord->iNetworkWeighting = 17;

	iapRecord->StoreL(*cmdbSession);

    iapRecord->iNetworkWeighting = 17;

    TBool found(EFalse);

    found = iapRecord->FindL(*cmdbSession); // this one should succeed

    INFO_PRINTF2(_L("Find returned %b, should be 1"), found);

	iapRecord->iNetworkWeighting = 13;

    found = iapRecord->FindL(*cmdbSession); // this one should fail

    INFO_PRINTF2(_L("Find returned %b, should be 0"), found);

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

    INFO_PRINTF2(_L("Store returned %d, should be -11"), storeErr); // this one should fail 

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

    iapRecord->iNetworkWeighting = 17;

	CleanupStack::Pop(iapRecord);

   	recordSet->iRecords.Append(iapRecord);

	found = recordSet->FindL(*cmdbSession);

    INFO_PRINTF2(_L("RecordSet FindL returned %b, should be 1"), found);

	delete recordSet;

	CleanupStack::PopAndDestroy(cmdbSession);

    if(found )

        {

        SetTestStepResult(EPass);	

	    }

    return TestStepResult();

	}

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

CCommsdat43Step::CCommsdat43Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat43Step);                                                                                           

	}

TVerdict CCommsdat43Step::doTestStepL()

/**

 * @return - TVerdict code

 * Test FindL, StoreL, LoadL for records

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("CCommsdat43Step::doTestStepL() in the file commsdat43Step.cpp"));

	CMDBSession *cmdbSession = NULL;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

 	cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

 	cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession);

	cmdbSession->OpenTransactionL();

	CCDIAPRecord *record = NULL;

	record = static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

	CleanupStack::PushL(record);

    record->SetRecordId(1);		

	record->iRecordTag = 13;

	TBool found(0);

	found = record->FindL(*cmdbSession);

	if(!found)

		{

		INFO_PRINTF2(_L("FindL found no record at id %08x"), record->ElementId());

		record->StoreL(*cmdbSession);

		cmdbSession->CommitTransactionL();

		}

	cmdbSession->Close();

	CleanupStack::PopAndDestroy(record);

	CleanupStack::PopAndDestroy(cmdbSession);

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

 	cmdbSession = CMDBSession::NewL(KCDVersion1_2);

#else

 	cmdbSession = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(cmdbSession);

	cmdbSession->OpenTransactionL();

	record = static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

	CleanupStack::PushL(record);

	record->iRecordTag = 13;

	found = record->FindL(*cmdbSession);

	if(found)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(record);

	cmdbSession->Close();

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

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

CCommsdat44Step::CCommsdat44Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat44Step);                                                                                           

	}

TVerdict CCommsdat44Step::doTestStepL()

/**

 * @return - TVerdict code

 * Test find, load, modify and store on individual fields of a record; record should be inserted with CED te_commsdat_iap_table1

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("I am in CCommsdat44Step::doTestStepL() and trying to test load, find, store, and modify"));

#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);

	TPtrC recordName(_L("TestName"));

	iapRecord->iRecordName.SetMaxLengthL(recordName.Length());

	iapRecord->iRecordName = recordName; 

	TBool found(EFalse);

	found = iapRecord->iRecordName.FindL(*cmdbSession);

	INFO_PRINTF2(_L("FindL for iap record name field returns %d - should be 1"), found);

    if(found)

		{

		// Now a test for loading a field that is not part of a record

        CMDBField<TDesC>* aField = new(ELeave) CMDBField<TDesC>(iapRecord->iRecordName.ElementId());

        CleanupStack::PushL(aField);

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

		INFO_PRINTF2(_L("LoadL for descriptor field returns %d - should be 0"), loadErr);

        if(loadErr == KErrNone)

			{

            // Now test for modifying a field

       		TPtrC recordName2(_L("TestName2"));

			iapRecord->iRecordName.SetMaxLengthL(recordName2.Length());

			iapRecord->iRecordName = recordName2;

			TRAPD(modifyErr, iapRecord->iRecordName.ModifyL(*cmdbSession));

		    INFO_PRINTF2(_L("ModifyL for iap record returns %d - should be 0"), modifyErr);

        	if(modifyErr == KErrNone)

				{

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

				CleanupStack::PushL(newIapRecord);

				newIapRecord->SetRecordId(KCDNewRecordRequest);

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

                INFO_PRINTF3(_L("StoreL for newIapRecord returns %d - should be 0.  Record id is %08x"), storeErr, newIapRecord->ElementId());

				TPtrC recordNameNew(_L("TestNameNew"));

				newIapRecord->iRecordName.SetMaxLengthL(recordNameNew.Length());

				newIapRecord->iRecordName = recordNameNew;

				TRAP(storeErr, newIapRecord->iRecordName.StoreL(*cmdbSession));

                INFO_PRINTF3(_L("StoreL for field in new IAP record returns %d - should be 0.  Record id is %08x"), storeErr, newIapRecord->ElementId());

				if(storeErr == KErrNone)

					{

					SetTestStepResult(EPass);

					}

				CleanupStack::PopAndDestroy(newIapRecord);

				}

			}

        CleanupStack::PopAndDestroy(aField);

		}

	CleanupStack::PopAndDestroy(iapRecord);

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult(); 

	}

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

CCommsdat45Step::CCommsdat45Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat45Step);

	}

TVerdict CCommsdat45Step::doTestStepL()

/**

 * @return - TVerdict code

 * Test find with more than one initialized fields 

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Testing find with multiple fields - CCommsdat45Step::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);

	CCDDefaultWCDMARecord *defaultWCDMARecord1 = (CCDDefaultWCDMARecord*)CCDRecordBase::RecordFactoryL(KCDTIdDefaultWCDMARecord); 

	CleanupStack::PushL(defaultWCDMARecord1);

	defaultWCDMARecord1->iUsage = 35;

	TPtrC apn3(_L("APN3"));

	defaultWCDMARecord1->iAPN.SetMaxLengthL(apn3.Length());

	defaultWCDMARecord1->iAPN = apn3;

	defaultWCDMARecord1->iPdpType = 252;

	CMDBRecordSet<CCDDefaultWCDMARecord>* recordSet1 = new(ELeave) CMDBRecordSet<CCDDefaultWCDMARecord>(KCDTIdDefaultWCDMARecord);

	CleanupStack::PushL(recordSet1);	

	recordSet1->iRecords.Append(defaultWCDMARecord1);

	TBool res(0);

	TRAPD(findErr1, res = recordSet1->FindL(*cmdbSession));

	INFO_PRINTF2(_L("FindL for record set returns %b"), res);

	CCDDefaultWCDMARecord *defaultWCDMARecord2 = (CCDDefaultWCDMARecord*)CCDRecordBase::RecordFactoryL(KCDTIdDefaultWCDMARecord); 

	CleanupStack::PushL(defaultWCDMARecord2);

	defaultWCDMARecord2->iUsage = 35;

	TPtrC apn(_L("APN"));

	defaultWCDMARecord2->iAPN.SetMaxLengthL(apn.Length());

	defaultWCDMARecord2->iAPN = apn;

	CMDBRecordSet<CCDDefaultWCDMARecord>* recordSet2 = new(ELeave) CMDBRecordSet<CCDDefaultWCDMARecord>(KCDTIdDefaultWCDMARecord);

	CleanupStack::PushL(recordSet2);	

	recordSet2->iRecords.Append(defaultWCDMARecord2);

	TRAPD(findErr2, res = recordSet2->FindL(*cmdbSession));

	CCDDefaultWCDMARecord *defaultWCDMARecord3 = (CCDDefaultWCDMARecord*)CCDRecordBase::RecordFactoryL(KCDTIdDefaultWCDMARecord); 

	CleanupStack::PushL(defaultWCDMARecord3);

	defaultWCDMARecord3->iUsage = 35;

	CMDBRecordSet<CCDDefaultWCDMARecord>* recordSet3 = new(ELeave) CMDBRecordSet<CCDDefaultWCDMARecord>(KCDTIdDefaultWCDMARecord);

	CleanupStack::PushL(recordSet3);	

	recordSet3->iRecords.Append(defaultWCDMARecord3);

	res = recordSet3->FindL(*cmdbSession);

	if(findErr1 == KErrNone && findErr2 == KErrNone && findErr2 == KErrNone)

		{

		if(recordSet1->iRecords.Count() == 1 && recordSet2->iRecords.Count() == 2 && recordSet3->iRecords.Count() == 3)

			{

			SetTestStepResult(EPass);

			}

		}

	CleanupStack::PopAndDestroy(recordSet3);	

	CleanupStack::Pop(defaultWCDMARecord3);	

	CleanupStack::PopAndDestroy(recordSet2);	

	CleanupStack::Pop(defaultWCDMARecord2);	

	CleanupStack::PopAndDestroy(recordSet1);	

	CleanupStack::Pop(defaultWCDMARecord1);	

	CleanupStack::PopAndDestroy(cmdbSession);

    return TestStepResult();

	}

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

CCommsdat46Step::CCommsdat46Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat46Step);                                                                                           

	}

TVerdict CCommsdat46Step::doTestStepL()

/**

 * @return - TVerdict code

 * Test Load on record set; should return KErrNotFound

 */

	{

    SetTestStepResult(EFail);	

	INFO_PRINTF1(_L("Load within transaction - CCommsdat46Step::doTestStepL() in the file commsdat46Step.cpp"));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

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

#else

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

#endif

	CleanupStack::PushL(cmdbSession); 

	cmdbSession->OpenTransactionL();

	CMDBRecordSet<CCDDialOutISPRecord>* recordSet = new(ELeave) CMDBRecordSet<CCDDialOutISPRecord>(KCDTIdDialOutISPRecord);

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

	if ( loadErr == KErrNotFound )

       	{

        SetTestStepResult(EPass);	

        }

	delete recordSet;

	cmdbSession->Close();

	CleanupStack::PopAndDestroy(cmdbSession);

	return TestStepResult();

	}

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

CCommsdat47Step::CCommsdat47Step()

/**

 * Constructor

 */

	{

	SetTestStepName(KCommsdat47Step);                                                                                           

	}

TVerdict CCommsdat47Step::doTestStepL()

/**

 * @return - TVerdict code

 * Store a RecordSet within a transaction

 */

	{

    SetTestStepResult(EFail);