--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/multimodetsy/test/Te_Misc/Te_Misc.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1305 @@
+// 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:
+// This file contains the main methods that test the Misc
+// Functionality of the MMTSY
+// 
+//
+
+/**
+ @file
+*/
+
+#include "Te_Misc.h"
+
+const TInt KOneSecond=1000000;		// Used in a time out function, 1 second (in microSeconds)
+
+
+/*-- Server info Test -----------------------------------------------------------------*/
+
+CServerInfo::CServerInfo()
+/** 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("ServerInfo"));
+	}
+
+TVerdict CServerInfo::doTestStepL( void )
+/**
+ * This function retrieves the number of phones supported by the loaded ETel Tsy
+ * Modules. Also gets information associated with the phone and queries the Tsy
+ * about its supported functionality.
+ */
+	{
+	TInt numOfPhones;
+	TESTL(iTelServer.EnumeratePhones(numOfPhones)==KErrNone);
+	INFO_PRINTF2(_L("No. of phones supported by loaded ETel modules = %d"), numOfPhones);
+
+	// Phone information
+	RTelServer::TPhoneInfo phoneInfo;
+	TEST_CHECKL(iTelServer.GetPhoneInfo(numOfPhones-1, phoneInfo),KErrNone, _L("Failed GetPhoneInfo()"));
+
+	// Get the Network Type
+	const TText* type=_S("Unknown");
+	switch(phoneInfo.iNetworkType)
+		{
+		case RTelServer::ENetworkTypeWiredAnalog:				
+			type=_S("Wired Analog Network"); break;
+		case RTelServer::ENetworkTypeWiredDigital:
+			type=_S("Wired Digital Network"); break;
+		case RTelServer::ENetworkTypeMobileAnalog:
+			type=_S("Mobile Analog Network"); break;
+		case RTelServer::ENetworkTypeMobileDigital:
+			type=_S("Mobile Digital Network"); break;
+		default:
+			type=_S("Unknown Network Type"); break;
+		}
+
+	INFO_PRINTF2(_L("Network Type : %s"), type);
+	INFO_PRINTF2(_L("Phone's name : %S"), &phoneInfo.iName);
+	INFO_PRINTF2(_L("No. of lines supported by the phone : %d"), phoneInfo.iNumberOfLines);
+	INFO_PRINTF2(_L("Extensions supported by Tsy Module : %d"), phoneInfo.iExtensions);
+	
+
+	// Query TSY about supported functionality
+	TBool result;
+	TInt mixin=1; // same value used by etel\tetel\t_hyres1.cpp
+
+	TBuf<10> tsyName;
+	tsyName = KMmtsyName;
+
+	TESTL(iTelServer.IsSupportedByModule(tsyName, mixin, result)==KErrNone);
+	INFO_PRINTF1(_L("Querying TSY about supported functionality is Successful"));
+
+	return TestStepResult();
+	}
+
+
+
+
+/*-- Signal And Battery Strength Test -------------------------------------------------*/
+
+CSignalAndBatteryStrengthTest::CSignalAndBatteryStrengthTest()
+/** 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("SignalAndBatteryStrengthTest"));
+	}
+
+TVerdict CSignalAndBatteryStrengthTest::doTestStepL( void )	
+/** 
+ * This method retrieves a phone's Signal and Battery Strength Information.
+ */
+	{
+	INFO_PRINTF1(_L("Get Signal And Battery Strength Information"));
+
+	// Test Getting Battery caps
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetBatteryCaps()"));
+	TUint32 aCaps;
+	TEST_CHECKL(iPhone.GetBatteryCaps(aCaps), KErrNone, _L("Failed RMobilePhone::GetBatteryCaps()")) ;
+
+	//Print Capabilities
+	if(aCaps & RMobilePhone::KCapsGetBatteryInfo)
+		{
+		INFO_PRINTF1(_L("Phone supports requests to get the current battery info"));
+		}
+	if(aCaps & RMobilePhone::KCapsNotifyBatteryInfoChange)
+		{
+		INFO_PRINTF1(_L("Phone supports requests for notification of change in battery information."));
+		}
+
+
+	//Test Getting Signal caps
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetSignalCaps()"));
+	TEST_CHECKL(iPhone.GetSignalCaps(aCaps), KErrNone, _L("Failed RMobilePhone::GetSignalCaps()"));
+
+	//Print Capabilities
+	if(aCaps & RMobilePhone::KCapsGetSignalStrength)
+		{
+		INFO_PRINTF1(_L("Phone supports requests to get the current signal strength"));
+		}
+	if(aCaps & RMobilePhone::KCapsNotifySignalStrengthChange)
+		{
+		INFO_PRINTF1(_L("Phone supports requests for notification of change in signal strength"));
+		}
+
+
+	//Test Getting Battery Info
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetBatteryInfo()"));
+	RMobilePhone::TMobilePhoneBatteryInfoV1 battery;
+	iPhone.GetBatteryInfo(iStatus, battery);
+	User::WaitForRequest(iStatus);
+	if (iStatus==KErrNone)
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Battery status : %d")), battery.iStatus);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Battery charge level : %d")), battery.iChargeLevel);
+		}
+	else
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Battery charge, Error %d returned.")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+
+	//Get Signal Strength
+	TInt32 signalStrength;
+	TInt8 bars;
+
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetSignalStrength()"));
+	iPhone.GetSignalStrength(iStatus, signalStrength, bars);
+	User::WaitForRequest(iStatus);
+	if (iStatus==KErrNone)
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Signal strength (in dBm) : %d")), signalStrength);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Signal strength (in display bars) : %d")), bars);
+		}
+
+	else
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Signal strength, Error %d returned.")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+
+	//Test Cancelling requests
+	INFO_PRINTF1(_L("Performing Cancel Requests for the above functions"));
+
+	iPhone.GetBatteryInfo(iStatus, battery);
+	iPhone.CancelAsyncRequest(EMobilePhoneGetBatteryInfo);
+	User::WaitForRequest(iStatus);
+	INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetBatteryInfo Cancel status = %d")), iStatus.Int());
+	User::After(1000000); //Wait for phone to produce response and for TSY to reject it
+
+	iPhone.GetSignalStrength(iStatus, signalStrength, bars);
+	iPhone.CancelAsyncRequest(EMobilePhoneGetSignalStrength);
+	User::WaitForRequest(iStatus);
+	INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetSignalStrength Cancel status = %d")), iStatus.Int());
+	User::After(1000000); //Wait for phone to produce response and for TSY to reject it
+
+	return TestStepResult();
+	}
+
+
+/*-- Manufacturer Info Test -----------------------------------------------------------*/
+CManufacturerInfoTest::CManufacturerInfoTest()
+/** 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("ManufacturerInfoTest"));
+	}
+
+TVerdict CManufacturerInfoTest::doTestStepL( void )	
+/** 
+ * This method retrieves a phone's Signal and Battery Strength Information.
+ */
+	{
+	INFO_PRINTF1(_L("Get Manufacturer ID, Model ID, Revision ID and Serial Number"));
+
+	//Test Getting Phone Identity Caps
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetIdentityCaps()"));
+	TUint32 aCaps;
+	TInt ret = iPhone.GetIdentityCaps(aCaps);
+	if(ret) 
+		{
+		INFO_PRINTF2(_L("RMobilePhone::GetIdentityCaps() returned %d"), ret);
+		SetTestStepResult(EFail);
+		}
+
+	if(aCaps & RMobilePhone::KCapsGetManufacturer)
+		{
+		INFO_PRINTF1(_L("Phone can return the identity of its manufacturer"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetModel)
+		{
+		INFO_PRINTF1(_L("Phone can return the identity of its model"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetRevision)
+		{
+		INFO_PRINTF1(_L("Phone can return the identity of its revision"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetSerialNumber)
+		{
+		INFO_PRINTF1(_L("Phone can return the identity of its serial number"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetSubscriberId)
+		{	
+		INFO_PRINTF1(_L("Phone can return the identity of its subscriber"));
+		}
+
+
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetPhoneId()"));
+	RMobilePhone::TMobilePhoneIdentityV1 phoneId;
+	iPhone.GetPhoneId(iStatus, phoneId);
+	User::WaitForRequest(iStatus);
+
+	if (iStatus==KErrNone)
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Manufacturer ID : %S")), &phoneId.iManufacturer);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Model ID : %S")), &phoneId.iModel);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Revision ID : %S")), &phoneId.iRevision);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Serial number : %S")), &phoneId.iSerialNumber);
+		}
+	else
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Error RMobilePhone::GetPhoneId() returned %d")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+		
+	return TestStepResult();	
+	}
+
+/*-- Subscriber ID Test -----------------------------------------------------------*/
+CSubscriberIdTest::CSubscriberIdTest()
+/** 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("SubscriberIdTest"));
+	}
+
+TVerdict CSubscriberIdTest::doTestStepL( void )	
+/** 
+ * This method retrieves a phone's subscriber ID
+ */
+	{
+	INFO_PRINTF1(_L("Get Subscriber ID"));
+
+	// Get subscriber ID test
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetSubscriberId()"));
+	RMobilePhone::TMobilePhoneSubscriberId subId;
+	iPhone.GetSubscriberId(iStatus, subId);
+	User::WaitForRequest(iStatus);
+	
+	// Do not consider KErrNotSupported return code as a test failure
+	if(iStatus==KErrNotSupported)
+		{	
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else if(iStatus!=KErrNone)
+		{
+		// Log that and error occurred
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetSubscriberId failed with status %d")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+	if(iStatus==KErrNone)
+		{
+		// Log the Subscriber ID returned
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("SubscriberId: %S")), &subId);
+		}
+							
+	
+	// Get subscriber ID and then cancel test
+	iPhone.GetSubscriberId(iStatus, subId);
+	iPhone.CancelAsyncRequest(EMobilePhoneGetSubscriberId);
+	User::WaitForRequest(iStatus);
+	INFO_PRINTF2(TRefByValue<const TDesC>(_L("RMobilePhone::GetSubscriberIdCancel status = %d")), iStatus.Int());
+
+	return TestStepResult();
+	}
+
+
+
+/*-- Phone Store Test -----------------------------------------------------------------*/
+
+CPhoneStoreTest::CPhoneStoreTest()
+/** 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("PhoneStoreTest"));
+	}
+
+TVerdict CPhoneStoreTest::doTestStepL( void )	
+/** 
+ * This method retrieves various phone store information
+ */	
+
+	{
+	// Get phone store info for various phonebook
+	INFO_PRINTF1(_L("Test the Phone Stores"));
+
+	//Get phone store info for IccAdnPhoneBook
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetPhoneStoreInfo() for KETelIccAdnPhoneBook"));
+	RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
+	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg infoPckg(info);
+	iPhone.GetPhoneStoreInfo(iStatus, infoPckg, KETelIccAdnPhoneBook);
+	User::WaitForRequest(iStatus);
+
+	if(iStatus==KErrNone)
+		{	
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &info.iName);
+		TESTL(info.iType==RMobilePhoneStore::EPhoneBookStore);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of used entries: %d")), info.iUsedEntries);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of total entries: %d")), info.iTotalEntries);
+		}
+	else if (iStatus==KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else 
+		{
+		// Log that and error occurred
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetPhoneStoreInfo failed with status %d")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+	//Get phonebook store info for MeAdnPhoneBook
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetPhoneStoreInfo() for KETelMeAdnPhoneBook"));
+	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phbkInfo;
+	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phbkInfoPckg(phbkInfo);
+	iPhone.GetPhoneStoreInfo(iStatus, phbkInfoPckg, KETelMeAdnPhoneBook);
+	User::WaitForRequest(iStatus);
+
+	if(iStatus==KErrNone)
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &phbkInfo.iName);
+		TESTL(phbkInfo.iType==RMobilePhoneStore::EPhoneBookStore);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of used entries: %d")), phbkInfo.iUsedEntries);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of total entries: %d")), phbkInfo.iTotalEntries);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max text length: %d")), phbkInfo.iMaxTextLength);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max number length: %d")), phbkInfo.iMaxNumLength);
+		}
+	else if(iStatus==KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetPhoneStoreInfo failed with status %d")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+	// Get phone store info for KETelOwnNumberStore
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetPhoneStoreInfo() for KETelOwnNumberStore"));
+	iPhone.GetPhoneStoreInfo(iStatus, infoPckg, KETelOwnNumberStore);
+	User::WaitForRequest(iStatus);
+
+	if(iStatus==KErrNone)
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &info.iName);
+		TESTL(info.iType==RMobilePhoneStore::EOwnNumberStore);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of used entries: %d")), info.iUsedEntries);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of total entries: %d")), info.iTotalEntries);
+		}
+	else if(iStatus==KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetPhoneStoreInfo failed with status %d")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+	//Get own number store information
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetPhoneStoreInfo() for KETelOwnNumberStore..."));
+	INFO_PRINTF1(_L("...but this time passing in a TMobileONStoreInfoV1Pckg"));
+	RMobileONStore::TMobileONStoreInfoV1 onInfo;
+	RMobileONStore::TMobileONStoreInfoV1Pckg onInfoPckg(onInfo);
+	iPhone.GetPhoneStoreInfo(iStatus, onInfoPckg, KETelOwnNumberStore);
+	User::WaitForRequest(iStatus);	
+
+	if(iStatus==KErrNone)
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &onInfo.iName);
+		TESTL(onInfo.iType==RMobilePhoneStore::EOwnNumberStore);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of used entries: %d")), onInfo.iUsedEntries);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of total entries: %d")), onInfo.iTotalEntries);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max text length: %d")), onInfo.iTextLen);
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max number length: %d")), onInfo.iNumberLen);
+		}
+	else if(iStatus==KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else
+		{
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetPhoneStoreInfo failed with status %d")), iStatus.Int());
+		SetTestStepResult(EFail);
+		}
+
+	return TestStepResult();
+	}
+
+
+/*-- Own Number Test ------------------------------------------------------------------*/
+
+COwnNumberTest::COwnNumberTest()
+/** 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("OwnNumberTest"));
+	}
+
+TVerdict COwnNumberTest::doTestStepL( void )	
+/** 
+ * This method test own number storage
+ */	
+	{
+	INFO_PRINTF1(_L("Own number tests"));
+	
+	RMobileONStore iOwnNumberStore;
+
+	// Check that TSY supports Own Number Store
+	TBool supported;
+	TInt ret;
+	
+	ret = iTelServer.IsSupportedByModule(KMmtsyName, KETelFuncMobileOwnNumberStore, supported);
+
+	if ((ret==KErrNone) && (supported))
+		{
+		// Open RMobileONStore
+		ret=iOwnNumberStore.Open(iPhone);
+
+		if (ret!=KErrNone)
+			{
+			INFO_PRINTF2(_L("Failed to open Own Number store (%d)"), ret);
+			return EFail;
+			}
+
+		// Get Own Number Information
+		RMobileONStore::TMobileONStoreInfoV1 ownNumberInfo;
+		RMobileONStore::TMobileONStoreInfoV1Pckg ownNumberInfoPckg(ownNumberInfo);
+	
+		iOwnNumberStore.GetInfo(iStatus, ownNumberInfoPckg);
+		User::WaitForRequest(iStatus);
+	
+		if ((iStatus==KErrNone) && (ownNumberInfo.iType==RMobilePhoneStore::EOwnNumberStore))
+			{
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &ownNumberInfo.iName);
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Caps: %d")), ownNumberInfo.iCaps);
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of Entries: %d")), ownNumberInfo.iUsedEntries);
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Maximum no. of entries: %d")), ownNumberInfo.iTotalEntries);
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max. length of tel.no: %d")), ownNumberInfo.iNumberLen);
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max. length of text: %d")), ownNumberInfo.iTextLen);
+			}
+		else if (iStatus==KErrNotSupported)
+			{
+			INFO_PRINTF1(TRefByValue<const TDesC>(_L("GetOwnNumberInfo not supported by this phone")));
+			}
+		else
+			{
+			INFO_PRINTF3(TRefByValue<const TDesC>(_L("GetOwnNumberInfo failed - status: %d, store type: %d")), iStatus.Int(), ownNumberInfo.iType);
+			SetTestStepResult(EFail);
+			}
+
+		// Own Number Entry
+		RMobileONStore::TMobileONEntryV1 ownNumberEntry;
+		RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg(ownNumberEntry);
+
+		for (TInt i=1; i<=ownNumberInfo.iTotalEntries; i++)
+			{
+			ownNumberEntry.iIndex = i;
+	
+			iOwnNumberStore.Read(iStatus, ownNumberEntryPckg);
+			User::WaitForRequest(iStatus);
+		
+			if (iStatus==KErrNone)
+				{	
+				INFO_PRINTF2(_L("GetOwnNumberEntry (%d) was successful"),i);
+				INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number: %S")), &ownNumberEntry.iNumber.iTelNumber);
+				}
+			else if (iStatus==KErrNotFound)
+				{
+				INFO_PRINTF2(_L("No Own Number Entry (%d) was found."),i);
+				}
+			else if (iStatus==KErrNotSupported)
+				{
+				INFO_PRINTF1(TRefByValue<const TDesC>(_L("GetOwnNumberEntry not supported by this phone")));
+				}
+			else
+				{	
+				INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetOwnNumberEntry status %d")), iStatus.Int());
+				}
+			}
+
+		// Close and reopen store to test read before getinfo request
+		iOwnNumberStore.Close();
+		ret=iOwnNumberStore.Open(iPhone);
+		if (ret!=KErrNone)
+			{
+			INFO_PRINTF2(_L("Failed to open Own Number store (%d)"), ret);
+			SetTestStepResult(EFail);
+			}
+
+		// Own Number Entry
+		RMobileONStore::TMobileONEntryV1 ownNumberEntry2;
+		ownNumberEntry2.iIndex = 2;
+	
+		RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg2(ownNumberEntry2);
+	
+		iOwnNumberStore.Read(iStatus, ownNumberEntryPckg2);
+		User::WaitForRequest(iStatus);
+		
+		if (iStatus==KErrNone)
+			{	
+			INFO_PRINTF1(_L("GetOwnNumberEntry (2) was successful"));
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number: %S")), &ownNumberEntry2.iNumber.iTelNumber);
+			}
+		else if (iStatus==KErrNotFound)
+			{
+			INFO_PRINTF1(_L("No Own Number Entry (2) was found."));
+			}
+		else if (iStatus==KErrNotSupported)
+			{
+			INFO_PRINTF1(TRefByValue<const TDesC>(_L("GetOwnNumberEntry not supported by this phone")));
+			}
+		else
+			{
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetOwnNumberEntry (index 2) status %d")), iStatus.Int());			
+			}
+
+
+		//Test Cancel Requests
+		INFO_PRINTF1(_L("Performing Cancel Requests for the above functions"));
+		iOwnNumberStore.GetInfo(iStatus, ownNumberInfoPckg);
+		iOwnNumberStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
+		User::WaitForRequest(iStatus);
+		if (iStatus!=KErrNotSupported)
+			{
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("RMobileONStore::GetInfoCancel status = %d")), iStatus.Int());
+			}
+
+		ownNumberEntry2.iIndex = 1;	
+		iOwnNumberStore.Read(iStatus, ownNumberEntryPckg2);
+		iOwnNumberStore.CancelAsyncRequest(EMobilePhoneStoreRead);
+		User::WaitForRequest(iStatus);
+		if (iStatus!=KErrNotSupported)
+			{
+			INFO_PRINTF2(TRefByValue<const TDesC>(_L("RMobileONStore::ReadCancel status = %d")), iStatus.Int());
+			}
+
+		iOwnNumberStore.Close();
+		}
+	else
+		{
+		INFO_PRINTF1(_L("TSY does not support Own Number store"));
+		}
+
+	return TestStepResult();
+	}
+
+
+/*-- Get Caps Test --------------------------------------------------------------------*/
+
+CGetCaps::CGetCaps()
+/** 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("GetCaps"));
+	}
+
+TVerdict CGetCaps::doTestStepL( void )	
+/** 
+ * This method test own number storage
+ */	
+	{
+	INFO_PRINTF1(_L("Get Phone Capabilities"));
+	
+	TInt ret;
+
+	// Get Caps and print them
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetCaps()"));
+	RPhone::TCaps aCaps;
+	ret = iPhone.GetCaps(aCaps);
+	if(ret) 
+		{
+		INFO_PRINTF2(_L("RMobilePhone::GetCaps() returned: %d"), ret);
+		SetTestStepResult(EFail);
+		}
+	if(aCaps.iFlags & RPhone::KCapsUnknown)
+		{
+		INFO_PRINTF1(_L("The capabilities of the phone are not currently known"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsData)
+		{
+		INFO_PRINTF1(_L("The phone supports data calls"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsFaxClassOne)
+		{
+		INFO_PRINTF1(_L("The phone supports the fax class 1 interface"));
+		}
+	if(aCaps.iFlags &	RPhone::KCapsFaxClassOnePointZero)
+		{
+		INFO_PRINTF1(_L("The phone supports the fax class 1.0 interface"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsFaxClassTwo)
+		{
+		INFO_PRINTF1(_L("The phone supports the fax class 2 interface"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsFaxClassTwoPointZero)
+		{
+		INFO_PRINTF1(_L("The phone supports the fax class 2.0 interface"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsFaxClassTwoPointOne)
+		{
+		INFO_PRINTF1(_L("The phone supports the fax class 2.1 interface"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsVoice)
+		{
+		INFO_PRINTF1(_L("The phone supports voice calls"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsEventModemDetection)
+		{
+		INFO_PRINTF1(_L("The phone supports modem detection events"));
+		}
+	if(aCaps.iFlags & RPhone::KCapsStealCommPort)
+		{
+		INFO_PRINTF1(_L("The phone supports the ability to take the comms port"));
+		}
+
+
+	// Gets Status and prints info
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetStatus()"));	
+	RPhone::TStatus phoneStatus;
+	ret = iPhone.GetStatus(phoneStatus);
+	if(ret) 
+		{
+		INFO_PRINTF2(_L("RMobilePhone::GetStatus() returned %d"), ret);
+		SetTestStepResult(EFail);
+		}
+
+	switch(phoneStatus.iMode)
+		{
+		case RPhone::EModeUnknown:
+			INFO_PRINTF1(_L("The phone is currently in an unknown state"));
+			break;
+
+		case RPhone::EModeIdle:
+			INFO_PRINTF1(_L("The phone is currently idle"));
+			break;
+
+		case RPhone::EModeEstablishingLink:
+			INFO_PRINTF1(_L("The phone is currently trying to establish a call"));
+			break;
+
+		case RPhone::EModeOnlineData:
+			INFO_PRINTF1(_L("The phone is in the connected and \"on-line data\" state"));
+			break;
+
+		case RPhone::EModeOnlineCommand:
+			INFO_PRINTF1(_L("The phone is in the connected and \"on-line command\" state"));
+			break;
+
+		}
+
+	//Get and print info
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetInfo()"));
+	RPhone::TPhoneInfo phoneInfo;
+	ret = iPhone.GetInfo(phoneInfo);
+	if(ret) 
+		{
+		INFO_PRINTF2(_L("RMobilePhone::GetInfo() returned %d"), ret);
+		SetTestStepResult(EFail);
+		}
+
+	switch(phoneInfo.iDetection)
+		{
+		case RPhone::EDetectedPresent:
+			INFO_PRINTF1(_L("The local modem is present"));
+			break;
+
+		case RPhone::EDetectedNotPresent:
+			INFO_PRINTF1(_L("The local modem is not present"));
+			break;
+
+		case RPhone::EDetectedUnknown:
+			INFO_PRINTF1(_L("Status of the local modem not detected"));
+			break;
+		}
+
+	return TestStepResult();
+	}
+
+
+/*-- Get Lines Status Test ------------------------------------------------------------*/
+
+CGetLinesStatus::CGetLinesStatus()
+/** 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("GetLinesStatus"));
+	}
+
+TVerdict CGetLinesStatus::doTestStepL( void )	
+/** 
+ * This method tests getting the line status
+ */	
+	{
+	INFO_PRINTF1(_L("Get Lines Status"));
+
+	TInt aCount;
+	TInt i;					// Loop counter
+	RPhone::TLineInfo	lineInfo;
+
+	//Test Enumeratting the lines
+	INFO_PRINTF1(_L("Calling RPhone::EnumerateLines()"));
+	TInt ret = iPhone.EnumerateLines(aCount);
+	if(ret) 
+		{
+		INFO_PRINTF2(_L("RPhone::EnumerateLines() returned %d"), ret);
+		SetTestStepResult(EFail);
+		}
+	
+	INFO_PRINTF2(_L("There are %d lines on this phone"), aCount);
+
+	INFO_PRINTF1(_L("Calling RPhone::GetLineInfo()"));
+	for(i=0;i<aCount;i++)
+		{
+		ret = iPhone.GetLineInfo(i, lineInfo);
+		if(ret) 
+			{
+			INFO_PRINTF2(_L("RPhone::GetLineInfo() returned %d"), ret);
+			SetTestStepResult(EFail);
+			}
+
+		switch(lineInfo.iStatus)
+			{
+			case RCall::EStatusUnknown:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call status is not currently known"), i+1, &lineInfo.iName);
+				break;
+
+			case RCall::EStatusIdle:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is idle"), i+1, &lineInfo.iName);
+				break;
+			
+			case RCall::EStatusDialling:   
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is dialling."), i+1, &lineInfo.iName);
+				break;
+
+			case RCall::EStatusRinging:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is ringing "), i+1, &lineInfo.iName);
+				break;
+
+			case RCall::EStatusAnswering:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is being answered"), i+1, &lineInfo.iName);
+				break;
+
+			case RCall::EStatusConnecting:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is connecting"), i+1, &lineInfo.iName);
+				break;
+
+			case RCall::EStatusConnected:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is connected and active"), i+1, &lineInfo.iName);
+				break;
+
+			case RCall::EStatusHangingUp:
+				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is being terminated"), i+1, &lineInfo.iName);
+				break;
+
+			}
+
+		// Waits a bit
+		User::After( 3 * KOneSecond);
+
+		if(lineInfo.iLineCapsFlags & RLine::KCapsData)
+			{
+			INFO_PRINTF1(_L("The line supports data connections"));
+			}	
+		if(lineInfo.iLineCapsFlags & RLine::KCapsFax)
+			{
+			INFO_PRINTF1(_L("The line supports fax connections"));
+			}
+		if(lineInfo.iLineCapsFlags & RLine::KCapsVoice)
+			{
+			INFO_PRINTF1(_L("The line supports voice connections"));
+			}
+		if(lineInfo.iLineCapsFlags & RLine::KCapsEventIncomingCall)
+			{
+			INFO_PRINTF1(_L("The line supports incoming call notification requests"));
+			}
+		}
+
+	return TestStepResult();
+	}
+
+/*-- Get Multimode Caps Test ----------------------------------------------------------*/
+
+CGetMultimodeCaps::CGetMultimodeCaps()
+/** 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("GetMultimodeCaps"));
+	}
+
+TVerdict CGetMultimodeCaps::doTestStepL( void )	
+/** 
+ * This method tests getting the phone's multimode capabilities
+ */	
+	{
+	INFO_PRINTF1(_L("Testing the phone's Multimode caps"));
+	
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetMultimodeCaps()"));
+	TUint32 aCaps;
+	TInt ret = iPhone.GetMultimodeCaps(aCaps);
+	if(ret) 
+		{
+		INFO_PRINTF2(_L("RMobilePhone::GetMultimodeCaps returned %d"), ret);
+		return EFail;
+		}
+
+	if(aCaps & RMobilePhone::KCapsGsmSupported)
+		{
+		INFO_PRINTF1(_L("Phone can operate in GSM 900/1800/1900 mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsGprsSupported)
+		{
+		INFO_PRINTF1(_L("Phone can operate in GPRS mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsAmpsSupported)
+		{
+		INFO_PRINTF1(_L("Phone can operate in AMPS 800 mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsCdma95Supported)
+		{
+		INFO_PRINTF1(_L("Phone can operate in CDMA95 800/1900 mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsCdma2000Supported)
+		{
+		INFO_PRINTF1(_L("Phone can operate in CDMA2000 800/1900 mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsWcdmaSupported)
+		{
+		INFO_PRINTF1(_L("Phone can operate in W-CDMA mode"));
+		}
+
+	return EPass;
+	}
+
+
+/*-- Get Network Caps Test ------------------------------------------------------------*/
+
+CGetNetworkCaps::CGetNetworkCaps()
+/** 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("GetNetworkCaps"));
+	}
+
+TVerdict CGetNetworkCaps::doTestStepL( void )	
+/** 
+ * This method tests getting Network Capabilities
+ */	
+	{
+	INFO_PRINTF1(_L("Get Network Caps"));
+
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetNetworkCaps()"));
+	TUint32 aCaps;
+	TInt ret = iPhone.GetNetworkCaps(aCaps);
+	if(ret==KErrNotSupported)	// Do not consider KErrNotSupported as a test failure
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else if(ret!=KErrNone) 
+		{
+		INFO_PRINTF2(_L("RMobilePhone::GetNetworkCaps() returned %d/n"), ret);
+		return EFail;
+		}
+
+	if(aCaps & RMobilePhone::KCapsGetRegistrationStatus)
+		{
+		INFO_PRINTF1(_L("The phone supports retrieval of current registration status"));
+		}
+	if(aCaps & RMobilePhone::KCapsNotifyRegistrationStatus)
+		{
+		INFO_PRINTF1(_L("The phone supports notifications of change in registration status"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetCurrentMode)
+		{
+		INFO_PRINTF1(_L("The phone supports retrieval of current mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsNotifyMode)
+		{
+		INFO_PRINTF1(_L("The phone supports notification of change in mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetCurrentNetwork)
+		{
+		INFO_PRINTF1(_L("phone supports retrieval of current network information"));
+		}
+	if(aCaps & RMobilePhone::KCapsNotifyCurrentNetwork)
+		{
+		INFO_PRINTF1(_L("The phone supports notification of change of current network"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetHomeNetwork)
+		{
+		INFO_PRINTF1(_L("The phone supports retrieval of home network information"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetDetectedNetworks)
+		{
+		INFO_PRINTF1(_L("The phone supports retrieval of a list of detected networks"));
+		}
+	if(aCaps & RMobilePhone::KCapsManualNetworkSelection)
+		{
+		INFO_PRINTF1(_L("The phone supports manual network selection mode"));
+		}
+	if(aCaps & RMobilePhone::KCapsGetNITZInfo)
+		{
+		INFO_PRINTF1(_L("The phone supports retrieval of time/date from the network"));
+		}
+	if(aCaps & RMobilePhone::KCapsNotifyNITZInfo)
+		{	
+		INFO_PRINTF1(_L("The phone supports notification of new updates of time/date from the network"));
+		}
+
+
+	return EPass;
+
+	}
+
+
+/*-- Get Current Mode Test ------------------------------------------------------------*/
+CGetCurrentMode::CGetCurrentMode()
+/** 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("GetCurrentMode"));
+	}
+
+TVerdict CGetCurrentMode::doTestStepL( void )	
+/** 
+ * This method tests getting the current mode that the phone is in
+ */	
+	{
+	INFO_PRINTF1(_L("Testing the current mode and notification"));
+	
+	INFO_PRINTF1(_L("Calling RMobilePhone::GetCurrentMode()"));
+	RMobilePhone::TMobilePhoneNetworkMode netMode;
+	TInt ret = iPhone.GetCurrentMode(netMode);
+	if(ret==KErrNotSupported)		// Do not consider KErrNotSupported as a test failure
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else if(ret!=KErrNone)
+		{	
+		// Log error code and return with error code so that AutoTest logs this as a test failure
+		INFO_PRINTF2(_L("RMobilePhone::GetCurrentMode() returned %d"), ret);
+		return EFail;
+		}
+
+	if(ret==KErrNone)
+		{
+		switch(netMode)
+			{
+		case RMobilePhone::	ENetworkModeUnregistered:
+			INFO_PRINTF1(_L("ME is not registered."));
+			break;
+		case RMobilePhone::ENetworkModeGsm:
+			INFO_PRINTF1(_L("GSM or DCS1800 network."));
+			break;
+		case RMobilePhone::ENetworkModeAmps:
+			INFO_PRINTF1(_L("AMPS network"));
+			break;
+		case RMobilePhone::ENetworkModeCdma95:
+			INFO_PRINTF1(_L("CDMA95 network."));
+			break;
+		case RMobilePhone::ENetworkModeCdma2000:
+			INFO_PRINTF1(_L("CDMA2000 network."));
+			break;
+		case RMobilePhone::ENetworkModeWcdma:
+			INFO_PRINTF1(_L("WCDMA network"));
+		case RMobilePhone::ENetworkModeTdcdma:
+			INFO_PRINTF1(_L("TD-CDMA network"));
+		case RMobilePhone::ENetworkModeUnknown:
+		default:
+			INFO_PRINTF1(_L("Network mode is unknown"));
+			break;
+			}
+		}
+	
+	return EPass;
+	}
+
+
+/*-- Async Network List Retrieval Test ------------------------------------------------*/
+
+CGetAsyncNetList::CTestAsyncGetNetList* CGetAsyncNetList::CTestAsyncGetNetList::NewLC(RMobilePhone& aPhone)
+	{
+    CTestAsyncGetNetList* r=new(ELeave) CTestAsyncGetNetList(aPhone);
+    CleanupStack::PushL(r);
+    r->ConstructL();
+    return r;
+    }
+      
+CGetAsyncNetList::CTestAsyncGetNetList::CTestAsyncGetNetList(RMobilePhone& aPhone)
+    : CActive(EPriorityNormal), iPhone(aPhone), iCompleteCode(KErrNone)
+    {
+	}
+      
+void CGetAsyncNetList::CTestAsyncGetNetList::ConstructL()
+	{
+	CActiveScheduler::Add(this);
+	iRetrieve=CRetrieveMobilePhoneDetectedNetworks::NewL(iPhone);
+    }
+         
+CGetAsyncNetList::CTestAsyncGetNetList::~CTestAsyncGetNetList()
+    {
+	delete iRetrieve;
+	}
+      
+void CGetAsyncNetList::CTestAsyncGetNetList::Start()
+    {
+    iRetrieve->Start(iStatus);
+    SetActive();
+    }       
+
+CMobilePhoneNetworkList* CGetAsyncNetList::CTestAsyncGetNetList::RetrieveList()
+	{
+	CMobilePhoneNetworkList* ptr=NULL;
+	TRAP_IGNORE(ptr=iRetrieve->RetrieveListL()); // trap and ignore err
+	return ptr;
+	}
+          
+void CGetAsyncNetList::CTestAsyncGetNetList::RunL()
+	{
+	iCompleteCode=iStatus.Int();
+	CActiveScheduler::Stop();
+	}	
+
+
+TInt CGetAsyncNetList::CTestAsyncGetNetList::CompleteCode()
+	{
+	return iCompleteCode;
+	}
+
+void CGetAsyncNetList::CTestAsyncGetNetList::DoCancel()
+    {
+    iRetrieve->Cancel();
+    }
+
+CGetAsyncNetList::CGetAsyncNetList()
+/** 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("GetAsyncNetList"));
+	}
+
+TVerdict CGetAsyncNetList::doTestStepL()
+/** 
+ * This method tests asynchronously getting a list of detected networks
+ */	
+	{
+	INFO_PRINTF1(_L("Testing Async retrieval of Network list"));
+
+	iTestScheduler = new (ELeave) CActiveScheduler;
+	CActiveScheduler::Install(iTestScheduler);
+
+	CTestAsyncGetNetList* netRetrieveList = CTestAsyncGetNetList::NewLC(iPhone);	
+	
+	INFO_PRINTF1(_L("Starting ActiveObject CRetrieveMobilePhoneDetectedNetworks"));
+	netRetrieveList->Start();
+	CActiveScheduler::Start();
+
+
+	// Get completion code from netRetrieveList
+	const TInt completeCode = netRetrieveList->CompleteCode();
+	if(completeCode==KErrNotSupported)		// Do not consider KErrNotSupported a test failure
+		{
+		INFO_PRINTF1(_L("***Phone returned KErrNotSupported***"));
+		}
+	else if(completeCode!=KErrNone)
+		{
+		// Log that and error occurred
+		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Failed with error code %d")),completeCode);
+		return EFail;
+		}
+
+
+	TInt i;			// Loop counter
+	CMobilePhoneNetworkList* retList=NULL;
+	RMobilePhone::TMobilePhoneNetworkInfoV1 anEntry;
+
+	if(completeCode==KErrNone)
+		{
+		retList = netRetrieveList->RetrieveList();
+		const TInt count = retList->Enumerate();
+		INFO_PRINTF2(_L("%d networks detected"), count);
+
+		for(i=0; i<count; i++)
+			{
+			anEntry = retList->GetEntryL(i);	
+			INFO_PRINTF3(_L("Network %d: %S"), i+1, &anEntry.iLongName);
+			INFO_PRINTF1(_L("Mode of the network: "));
+		
+			switch(anEntry.iMode)
+				{
+			case RMobilePhone::ENetworkModeUnregistered:
+				INFO_PRINTF1(_L("ME is not registered."));
+				break;
+			case RMobilePhone::ENetworkModeGsm:
+				INFO_PRINTF1(_L("GSM or DCS1800 network."));
+				break;
+			case RMobilePhone::ENetworkModeAmps:
+				INFO_PRINTF1(_L("	AMPS network"));
+				break;
+			case RMobilePhone::ENetworkModeCdma95:
+				INFO_PRINTF1(_L("CDMA95 network"));
+				break;
+			case RMobilePhone::ENetworkModeCdma2000:
+				INFO_PRINTF1(_L("CDMA2000 network"));
+				break;
+			case RMobilePhone::ENetworkModeWcdma:
+				INFO_PRINTF1(_L("WCDMA network."));
+				break;
+			case RMobilePhone::ENetworkModeTdcdma:
+				INFO_PRINTF1(_L("TD-CDMA network."));
+				break;
+			case RMobilePhone::ENetworkModeUnknown:
+			default:
+				INFO_PRINTF1(_L("Network mode is unknown."));
+				break;
+				}
+	
+			INFO_PRINTF1(_L("Status of the network: "));
+			switch(anEntry.iStatus)
+				{
+			case RMobilePhone::ENetworkStatusUnknown:
+				INFO_PRINTF1(_L("Status is unknown"));
+				break;
+			case RMobilePhone::ENetworkStatusAvailable:
+				INFO_PRINTF1(_L("A network that the ME is allowed to register to"));
+				break;
+			case RMobilePhone::ENetworkStatusCurrent:
+				INFO_PRINTF1(_L("The currently registered network."));
+				break;
+			case RMobilePhone::ENetworkStatusForbidden:
+				INFO_PRINTF1(_L("A network that the ME is not allowed to register to"));
+				break;
+				}
+
+			INFO_PRINTF2(_L("Country code: %S"), &anEntry.iCountryCode);
+			INFO_PRINTF2(_L("The system identity (SID) of the CDMA network: %S"), &anEntry.iCdmaSID);
+			INFO_PRINTF2(_L("The system identity (SID) of the AMPS network: %S"), &anEntry.iAnalogSID);
+			INFO_PRINTF2(_L("The network identity (NID in CDMA and MNC in GSM): %S"), &anEntry.iNetworkId);
+			INFO_PRINTF2(_L("The alpha-tag displayed when this is the serving network: %S"), &anEntry.iDisplayTag);
+			INFO_PRINTF2(_L("The short name (up to 8 characters) of the network operator: %S"), &anEntry.iShortName);
+			INFO_PRINTF2(_L("The long name (up to 16 characters) of the network operator.: %S"), &anEntry.iLongName);
+			}
+
+		}
+	CleanupStack::PopAndDestroy(); // netRetrieveList;
+	delete retList;
+	delete iTestScheduler;
+	return EPass;
+	}
+
+
+/*-- Functional Unit Support Test -----------------------------------------------------*/
+CIsSupportedByModuleTest::CIsSupportedByModuleTest()
+/** 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("IsSupportedByModuleTest"));
+	}
+
+
+TBool CIsSupportedByModuleTest::doIsSupportedByModuleTest(TInt aMixin)
+	{
+	TBool isSupported(EFalse);
+	TInt ret=iTelServer.IsSupportedByModule(KMmtsyName,aMixin,isSupported);
+	if(ret==KErrNone)
+		{
+		INFO_PRINTF2(_L("%d functional unit is supported!"), aMixin);
+		return ETrue;		
+		}		
+	else
+		{
+		INFO_PRINTF2(_L("%d functional unit is NOT supported"), aMixin);
+		return EFalse;
+		}
+	}
+
+TVerdict CIsSupportedByModuleTest::doTestStepL( void )	
+/** 
+ * This method tests is certain Functional Units are supported
+ */	
+	{
+	TBool isSupported(EFalse);
+	
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileNetwork);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileIdentity);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobilePower);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileSignal);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileDataCall);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileSmsMessaging);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobilePhonebook);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileSmsStore);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+	isSupported = doIsSupportedByModuleTest(KETelFuncMobileOwnNumberStore);
+	if(!isSupported)
+		{
+		SetTestStepResult(EFail);
+		}
+	return TestStepResult();
+	}