// Copyright (c) 1997-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 <e32test.h>

#include "TE_EtelMMTestStepBase.h"
#include "TE_mmonstore.h"
#include "testdef.h"

CTestOnStore::CTestOnStore()
/** Each test step initialises it's own name
*/
	{
	// store the name of this test case
	// this is the name that is used by the script file
	SetTestStepName(_L("TestOnStore"));
	}

enum TVerdict CTestOnStore::doTestStepL()
//
// Test ON Storage Functions
//
    {
	iTestCount=1;
	INFO_PRINTF1(_L(""));
	INFO_PRINTF1(_L("Test Mobile Own Number Storage Functionality"));
//	LOGTEXT(_L8("Test Mobile Own Number Storage Functionality"));
	
	RMobilePhone mmPhone;
	TInt ret=mmPhone.Open(iTelServer,DMMTSY_PHONE_NAME);
	TEST(ret==KErrNone);

	RMobileONStore onStore;
	ret=onStore.Open(mmPhone);
    TEST(ret==KErrNone);

	TRequestStatus reqStatus;
	

	// Get ON store information

	// asynchronous

	RMobileONStore::TMobileONStoreInfoV1 asyncInfo;
	RMobileONStore::TMobileONStoreInfoV1Pckg asyncInfoPckg(asyncInfo);
	onStore.GetInfo(reqStatus, asyncInfoPckg);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);
	ValidateONInfo(asyncInfo);

	// asynchronous & cancel

	onStore.GetInfo(reqStatus, asyncInfoPckg);
	onStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
	if (reqStatus.Int()==KErrCancel)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::GetInfo (async & cancel (Cancelled Request)) passed"), iTestCount++);
		
	else
		{
		ValidateONInfo(asyncInfo);
		INFO_PRINTF2(_L("Test %d - RMobileONStore::GetInfo (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
		}

//	test.Next(_L("OK: RMobileONStore's Get Info"));

	
	// Read one entry

	RMobileONStore::TMobileONEntryV1 asyncEntry1;

	// asynchronous

	asyncEntry1.iIndex = DMMTSY_ON_STORE_INDEX1;
	RMobileONStore::TMobileONEntryV1Pckg asyncEntry1Pckg(asyncEntry1);

	onStore.Read(reqStatus,asyncEntry1Pckg);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);

	ValidateONRead(asyncEntry1);


	// cancel

	asyncEntry1.iIndex = DMMTSY_ON_STORE_INDEX1;
	onStore.Read(reqStatus, asyncEntry1Pckg);
	onStore.CancelAsyncRequest(EMobilePhoneStoreRead);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
	if (reqStatus.Int()==KErrCancel)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::Read (async & cancel (Cancelled Request)) passed"), iTestCount++);	
	else
		{
		ValidateONRead(asyncEntry1);
		INFO_PRINTF2(_L("Test %d - RMobileONStore::Read (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
		}

//	test.Next(_L("OK: RMobileONStore's Read Entry"));

	// Write one entry

	RMobileONStore::TMobileONEntryV1 entry2;
	RMobileONStore::TMobileONEntryV1Pckg entry2Pckg(entry2);

	InitONEntry(entry2);

	// asynchronous

	entry2.iIndex=DMMTSY_ON_STORE_INDEX2;
	onStore.Write(reqStatus, entry2Pckg);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);

	// aynchronous & cancel

	onStore.Write(reqStatus, entry2Pckg);
	onStore.CancelAsyncRequest(EMobilePhoneStoreWrite);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::Write (async & cancel (Cancelled Request)) passed"), iTestCount++);
	else
		INFO_PRINTF2(_L("Test %d - RMobileONStore::Write (async & cancel (Request Not Cancelled)) passed"), iTestCount++);		

//	test.Next(_L("OK: RMobileONStore's Write Entry"));

	// Delete one entry

	// asynchronous	

	onStore.Delete(reqStatus, DMMTSY_ON_STORE_INDEX1);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);

	// cancel

	onStore.Delete(reqStatus, DMMTSY_ON_STORE_INDEX1);
	onStore.CancelAsyncRequest(EMobilePhoneStoreDelete);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)		
		INFO_PRINTF2(_L("Test %d - RMobileONStore::Delete (async & cancel (Cancelled Request)) passed"), iTestCount++);
	else
		INFO_PRINTF2(_L("Test %d - RMobileONStore::Delete (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Delete all entries

	// asynchronous

	onStore.DeleteAll(reqStatus);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);

	// asynchronous & cancel

	onStore.DeleteAll(reqStatus);
	onStore.CancelAsyncRequest(EMobilePhoneStoreDeleteAll);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
	if (reqStatus.Int()==KErrCancel)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::DeleteAll (async & cancel (Cancelled Request)) passed"), iTestCount++);
	else
		INFO_PRINTF2(_L("Test %d - RMobileONStore::DeleteAll (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

//	test.Next(_L("OK: RMobileonStore's Delete Entries"));

	
	// Notify Entry Changed

	// asynchronous
	TInt index;

	TUint32 event;
	onStore.NotifyStoreEvent(reqStatus, event, index);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);
	TEST(index==DMMTSY_ON_STORE_INDEX2);
	TEST(event==DMMTSY_ON_STORE_EVENT);

	// asychronous & cancel

	onStore.NotifyStoreEvent(reqStatus, event, index);
	onStore.CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
	if (reqStatus.Int()==KErrCancel)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::NotifyStoreEvent (async & cancel (Cancelled Request)) passed"), iTestCount++);
	else
		{
		TEST(index==DMMTSY_ON_STORE_INDEX2);
		TEST(event==DMMTSY_ON_STORE_EVENT);
		INFO_PRINTF2(_L("Test %d - RMobileONStore::NotifyStoreEvent (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
		}

//	test.Next(_L("OK: RMobileONStore's Notify Store Event change"));


	// Read all ON entries

	//Test deletion of list object whilst async request in progress
 	CRetrieveMobilePhoneONList* retrieve=CRetrieveMobilePhoneONList::NewL(onStore);
    retrieve->Start(reqStatus);
    delete retrieve;
 	retrieve = NULL;
 	User::WaitForRequest(reqStatus);
 	TEST(reqStatus == KErrCancel);

	// Get ON list using asynchronous AO version
	CTestGetONList* getONList=CTestGetONList::NewLC(onStore, this);
    getONList->Start();
    CActiveScheduler::Start();

	// Ensure that the same AO can be used to retrieve multiple lists.

    getONList->Start();
    CActiveScheduler::Start();

	// I only need to delete the retrieval object because the destructor
	// of this will also delete the list object.
    CleanupStack::PopAndDestroy();  // getONList

	// Now test the cancelling

	getONList=CTestGetONList::NewLC(onStore, this);
    getONList->Start();

	CTestCanceller* cancelGetONList = getONList->RetrieveCancelPtr();
	cancelGetONList->Call();

    CActiveScheduler::Start();
	TBool cancelled = (getONList->iStatus == KErrCancel);

    getONList->Start();
    CActiveScheduler::Start();

	if (cancelled)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::ReadAll (sync & async & cancel (Cancelled Request)) passed"), iTestCount++);
	else
		INFO_PRINTF2(_L("Test %d - RMobileONStore::ReadAll (sync & async & cancel (Request Not Cancelled)) passed"), iTestCount++);


    CleanupStack::PopAndDestroy();  // getONList

//	test.Next(_L("OK: RMobileONStore's Read All Entries"));

	// Storing a new version of the list


	RMobileONStore::TMobileONEntryV1 storeEntry;

	CMobilePhoneONList* onList = CMobilePhoneONList::NewL();
	CleanupStack::PushL(onList);

	InitONEntry(storeEntry);
	storeEntry.iIndex = DMMTSY_ON_STORE_INDEX1;

	onList->AddEntryL(storeEntry);
	storeEntry.iIndex = DMMTSY_ON_STORE_INDEX2;
	onList->AddEntryL(storeEntry);

	// asynchronous

	onStore.StoreAllL(reqStatus, onList);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);

	// aynchronous & cancel

	onStore.StoreAllL(reqStatus, onList);
	onStore.CancelAsyncRequest(EMobileONStoreStoreAll);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
	cancelled = (reqStatus.Int()==KErrCancel);

	// Ensure that a Store operation can be performed after the previous store had been cancelled.

	onStore.StoreAllL(reqStatus, onList);
	User::WaitForRequest(reqStatus);
	TEST(reqStatus.Int()==KErrNone);
	
	if (cancelled)
		INFO_PRINTF2(_L("Test %d - RMobileONStore::StoreAll (sync & async & cancel (Cancelled Request)) passed"), iTestCount++);
	else
		INFO_PRINTF2(_L("Test %d - RMobileONStore::StoreAll (sync & async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	CleanupStack::PopAndDestroy(); // namList

//	test.Next(_L("OK: RMobileONStore's Store All Entries"));

	onStore.Close();
	mmPhone.Close();
	INFO_PRINTF1(_L(""));
	
	return TestStepResult();
	}

void CTestOnStore::ValidateONInfo(const RMobileONStore::TMobileONStoreInfoV1 &aInfo)
	{
	TEST(aInfo.iName.Compare(DMMTSY_ON_STORE_NAME) == 0);
	TEST(aInfo.iType==DMMTSY_ON_STORE_TYPE);
	TEST(aInfo.iTotalEntries==DMMTSY_ON_STORE_ENTRIES);
	TEST(aInfo.iUsedEntries==DMMTSY_ON_STORE_USED);
	TEST(aInfo.iCaps==DMMTSY_ON_STORE_CAPS);

	TEST(aInfo.iNumberLen == DMMTSY_ON_STORE_INFO_GSM_MAX_NUM);
	TEST(aInfo.iTextLen == DMMTSY_ON_STORE_INFO_GSM_MAX_TEXT);
	TEST(aInfo.ExtensionId()==RMobilePhoneStore::KETelMobileONStoreV1);
	}

void CTestOnStore::ValidateONEntry(const RMobileONStore::TMobileONEntryV1 &aEntry)
	{
	TEST(aEntry.iMode == DMMTSY_ON_STORE_ENTRY_MODE);
	TEST(aEntry.iText.Compare(DMMTSY_ON_STORE_ENTRY_TEXT) == 0);
	TEST(aEntry.iNumber.iTypeOfNumber == DMMTSY_PHONE_TON);
	TEST(aEntry.iNumber.iNumberPlan == DMMTSY_PHONE_NPI);
	TEST(aEntry.iNumber.iTelNumber.Compare(DMMTSY_PHONE_TEL_NUMBER) == 0);
	TEST(aEntry.iService == DMMTSY_ON_STORE_ENTRY_SERVICE);
	}

void CTestOnStore::ValidateONRead(const RMobileONStore::TMobileONEntryV1 &aEntry)
	{
	ValidateONEntry(aEntry);
	}

void CTestOnStore::InitONEntry(RMobileONStore::TMobileONEntryV1& aEntry)
	{
	aEntry.iMode = DMMTSY_ON_STORE_ENTRY_MODE;
	aEntry.iText = DMMTSY_ON_STORE_ENTRY_TEXT;
	aEntry.iNumber.iTypeOfNumber = DMMTSY_PHONE_TON;
	aEntry.iNumber.iNumberPlan = DMMTSY_PHONE_NPI;
	aEntry.iNumber.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;
	aEntry.iService = DMMTSY_ON_STORE_ENTRY_SERVICE;
	}

/**************************************************************/
//
// Testing asynchronous retrieve of ON list
//
/**************************************************************/

CTestOnStore::CTestGetONList* CTestOnStore::CTestGetONList::NewLC(RMobilePhoneStore& aStore, CTestOnStore* aTestOnStore)
	{
    CTestGetONList* r=new(ELeave) CTestGetONList(aStore, aTestOnStore);
    CleanupStack::PushL(r);
    r->ConstructL();
    return r;
    }
      
CTestOnStore::CTestGetONList::CTestGetONList(RMobilePhoneStore& aStore, CTestOnStore* aTestOnStore)
    : CActive(EPriorityNormal), iStore(aStore), iTestOnStore(aTestOnStore)
    {}
      

void CTestOnStore::CTestGetONList::ConstructL()
	{
    CActiveScheduler::Add(this);
	iRetrieve=CRetrieveMobilePhoneONList::NewL(iStore);
	iCanceller=new (ELeave) CTestCanceller(this);
    }
         
CTestOnStore::CTestGetONList::~CTestGetONList()
    {
    delete iRetrieve;
	delete iCanceller;
	}
      
void CTestOnStore::CTestGetONList::Start()
    {
    iRetrieve->Start(iStatus);
	TRequestStatus tmpStatus;
	iRetrieve->Start(tmpStatus);
	User::WaitForRequest(tmpStatus);
	iTestOnStore->TEST(tmpStatus.Int() == KErrInUse);
    SetActive();
    }       
      
CTestCanceller* CTestOnStore::CTestGetONList::RetrieveCancelPtr()
	{
	return iCanceller;
	}
     
void CTestOnStore::CTestGetONList::RunL()
    {
    TInt ret=iStatus.Int();

    User::LeaveIfError(ret);
	ret=CheckResults();
	User::LeaveIfError(ret);

    CActiveScheduler::Stop();
	}
      

void CTestOnStore::CTestGetONList::DoCancel()
    {
    iRetrieve->Cancel();
    }       
      

TInt CTestOnStore::CTestGetONList::CheckResults()
    {
	TInt ret=KErrNone;

	CMobilePhoneONList* onList=NULL;
	TInt leaveCode=KErrNone;
	TRAP(leaveCode, onList=iRetrieve->RetrieveListL(););

	if (onList)
		{
		iTestOnStore->TEST(onList->Enumerate()==DMMTSY_ON_STORE_COUNT);

		// Get each detected network entry
		RMobileONStore::TMobileONEntryV1 entry;

		for (TInt i=0; i<DMMTSY_ON_STORE_COUNT; ++i)
			{
			TRAP(ret,entry=onList->GetEntryL(i));
			if (ret != KErrNone)
				break;
			switch(i)
				{
				case 0:
					{
					iTestOnStore->ValidateONEntry(entry);
					iTestOnStore->TEST(entry.iIndex==DMMTSY_ON_STORE_INDEX1);
					break;
					}
				case 1:
					{
					iTestOnStore->ValidateONEntry(entry);
					iTestOnStore->TEST(entry.iIndex==DMMTSY_ON_STORE_INDEX2);
					break;
					}
				default:
					break;
				}
			}
		delete onList;
		}

   return ret;
   }