// Copyright (c) 2001-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:

// Telephony Watchers Integration Test main test code.

// 

//

/**

 @file

*/

#include <e32uid.h>

#include <f32file.h>

#include <bafindf.h>

#include <cdbcols.h>

#include <simtsy.h>

#include <ecom/ecom.h>

#include "indicatorwatcher.h"

#include "signalstrengthwatcher.h"

#include "TE_TelWatchersIntBase.h"

#include "TE_TelWatchersIntTest.h"

/**

 *  Each test step initialises it's own name

 */

CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestRetrieveSignalStrengthWithPublishSubscribe"));

	} // CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::~CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::~CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe

/**

 *  This test tests the retrieval of the signal strength.

 *

 *  @test GT83-SSW-Test01 Test retrieval of the Signal Strength setting.

 */	

enum TVerdict CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::doTestStepL()

	{

	//

	// Make sure watchers are stopped and unloaded before running this test

	// This forces SIMTSY to be loaded again.

	//

	StopWatcher();

	SetSimTsyTestNumberL(0);

	StartWatcher();

	CheckSimTsyTestNumberL(0);

	TInt  state;

	TRequestStatus  localStatus;

	RProperty       localProperty;

	//-- attach and subscribe to KUidNetworkStrength property

	TESTCHECKL(localProperty.Attach(KUidSystemCategory,KUidNetworkStrength.iUid), KErrNone);    

	localProperty.Subscribe(localStatus);

	TInt ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Initial Signal Strength State is %d"), state);

	INFO_PRINTF1(_L("Commence Wait for Request local status..."));

	INFO_PRINTF2(_L("Prior to wait cycle, status is %d"), localStatus.Int());

	User::WaitForRequest(localStatus);			

	INFO_PRINTF1(_L("Complete Wait for Request local status."));

	localProperty.Subscribe(localStatus);

	ret = localProperty.Get(state);	

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Signal Strength State is %d"), state);

	TESTCHECK(state, ESANetworkStrengthNone);

	User::WaitForRequest(localStatus);		

	ret = localProperty.Get(state);

	localProperty.Subscribe(localStatus);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Signal Strength State is %d"),state);

	TESTCHECK(state, ESANetworkStrengthLow);

	User::WaitForRequest(localStatus);		

	ret = localProperty.Get(state);

	localProperty.Subscribe(localStatus);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Signal Strength State is %d"),state);

	TESTCHECK(state, ESANetworkStrengthMedium);

	User::WaitForRequest(localStatus);	

	ret = localProperty.Get(state);	

	localProperty.Subscribe(localStatus);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Signal Strength State is %d"),state);

	TESTCHECK(state, ESANetworkStrengthHigh);

	User::WaitForRequest(localStatus);		

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Signal Strength State is %d"),state);

	TESTCHECK(state, ESANetworkStrengthUnknown);

	return TestStepResult();

	} // CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe::CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestRetrieveChargerStatusWithPublishSubscribe"));

	} // CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe::CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe::~CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe::~CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe

/**

 *  This tests the retrieval of the charger Strength.  ESAChargerNotCharging

 *  does not appear to be used in the indicatorwatcher, apart from the

 *  #ifdef'ed test code that is not available to this "in situ" test.

 *

 *  @test GT83-SSW-Test02 Test retrieval of the Battery and Charger setting.

 */	

enum TVerdict CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe::doTestStepL()

	{

	//

	// Make sure watchers are stopped and unloaded before running this test.

	// This forces SIMTSY to be loaded again.

	//

	StopWatcher();

	SetSimTsyTestNumberL(1);

	StartWatcher();

	TInt  state;

	TRequestStatus  localStatus;

	RProperty       localProperty;

	//-- attach and subscribe to KUidChargerStatus property

	TInt ret = localProperty.Attach(KUidSystemCategory,KUidChargerStatus.iUid);

	TESTCHECKL(ret, KErrNone);

	localProperty.Subscribe(localStatus);  

	//

	// Get initial battery charge state

	//

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Initial Battery Charger State is %d"), state);

	User::WaitForRequest(localStatus);		

	localProperty.Subscribe(localStatus);

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Battery Charger State is %d"), state);

	TESTCHECK(state, ESAChargerConnected);

	User::WaitForRequest(localStatus);		

	localProperty.Subscribe(localStatus);

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Battery Charger State is %d"), state);

	TESTCHECK(state, ESAChargerDisconnected);

	User::WaitForRequest(localStatus);		

	localProperty.Subscribe(localStatus);

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Battery Charger State is %d"), state);

	TESTCHECK(state, KErrUnknown);

	User::WaitForRequest(localStatus);

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Battery Charger State is %d"), state);

	TESTCHECK(state, ESAChargerConnected);

	CheckSimTsyTestNumberL(1);

	return TestStepResult();

	} // CTelWatchersIntTestRetrieveChargerStatusWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersIntTestNetworkStatusWithPublishSubscribe::CTelWatchersIntTestNetworkStatusWithPublishSubscribe()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestNetworkStatusWithPublishSubscribe"));

	} // CTelWatchersIntTestNetworkStatusWithPublishSubscribe::CTelWatchersIntTestNetworkStatusWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersIntTestNetworkStatusWithPublishSubscribe::~CTelWatchersIntTestNetworkStatusWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersIntTestNetworkStatusWithPublishSubscribe::~CTelWatchersIntTestNetworkStatusWithPublishSubscribe

/**

 *  This tests the retrieval of the Network Status.

 *

 *  @test GT83-SSW-Test03 Test retrieval of the Network status information.

 */	

enum TVerdict CTelWatchersIntTestNetworkStatusWithPublishSubscribe::doTestStepL()

	{

	//

	// Make sure watchers are stopped and unloaded before running this test.

	// This forces SIMTSY to be loaded again.

	//

	StopWatcher();

	SetSimTsyTestNumberL(2);

	StartWatcher();

	TInt  state;

	TRequestStatus  localStatus;

	RProperty       localProperty;

	//

	// Get initial network available status...

	//

	TInt ret = RProperty::Get(KUidSystemCategory, KUidChargerStatus.iUid, state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Initial Network Available Status is %d"), state);

	//-- attach and subscribe to KUidNetworkStatus property

	ret = localProperty.Attach(KUidSystemCategory,KUidNetworkStatus.iUid);

	TESTCHECKL(ret, KErrNone);

	localProperty.Subscribe(localStatus);

	User::WaitForRequest(localStatus);		

	localProperty.Subscribe(localStatus);

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Network Available Status is %d"), state);

	TESTCHECK(state, ESANetworkAvailable);

	User::WaitForRequest(localStatus);		

	ret = localProperty.Get(state);

	TESTCHECKL(ret, KErrNone);

	INFO_PRINTF2(_L("Network Available Status is %d"), state);

	TESTCHECK(state, ESANetworkUnAvailable);

	CheckSimTsyTestNumberL(2);

	return TestStepResult();

	} // CTelWatchersIntTestNetworkStatusWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestOutgoingCallStatusWithPublishSubscribe"));

	} // CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::~CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersIntTestOutgoingCallStatus::~CTelWatchersIntTestOutgoingCallStatus

/**

 *  "Outgoing Call" function.  This function will wait until the

 *  Watchers have started and then will make and terminate a call.

 */

void CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::OutgoingCallL()

	{

	const TInt KStartupPollPeriod = 1*1000000;

	const TInt KCallActivePeriod  = 5*1000000;

	TInt val(KErrNotFound);

	while (val < KErrNone)

		{

		User::After(KStartupPollPeriod);

		User::LeaveIfError(RProperty::Get(KUidSystemCategory, KUidCurrentCall.iUid, val));

		}

	RTelServer  telServer;

	User::LeaveIfError(telServer.Connect());

	CleanupClosePushL(telServer);

	RPhone  phone;

	User::LeaveIfError(phone.Open(telServer, KPhoneName));

	CleanupClosePushL(phone);

	RLine  line;

	User::LeaveIfError(line.Open(phone, KVoiceLineName));

	CleanupClosePushL(line);

	RCall  call;

	TName  callName;

	User::LeaveIfError(call.OpenNewCall(line, callName));

	CleanupClosePushL(call);

	_LIT(KTelNumber,"1234");

	User::LeaveIfError(call.Dial(KTelNumber));

	User::After(KCallActivePeriod);

	call.HangUp();

	CleanupStack::PopAndDestroy(&call);

	CleanupStack::PopAndDestroy(&line);

	CleanupStack::PopAndDestroy(&phone);

	CleanupStack::PopAndDestroy(&telServer);

	} // CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::OutgoingCallL

/**

 *  "Outgoing Call Thread" function.  This function just calls OutgoingCallL.

 *

 *  @param  aPtr  A pointer to a CTelWatchersIntTestOutgoingCallStatus object.

 *  @return TInt  Standard error code.

 */

TInt CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::OutgoingCallThreadFunction(TAny* aPtr)

	{

  	CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe*  testStep =

  			REINTERPRET_CAST(CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe*, aPtr);

	//

	// Create a clean up stack...

	//

	CTrapCleanup*  cleanup;

	cleanup = CTrapCleanup::New();

	if (cleanup == NULL)

		{

		return KErrGeneral;

		}

	//

	// Call the OutgoingCallL() function...

	//

	TRAPD(leaveCode, testStep->OutgoingCallL());

	//

	// Clean up the clean up stack.

	//

	delete cleanup;

	return leaveCode;

	} // CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::OutgoingCallThreadFunction

/**

 *  This tests the retrieval of the Current MO Call State.

 */	

enum TVerdict CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::doTestStepL()

	{

	const TInt  KStackSize   = 0x8000;

	const TInt  KHeapSize    = 0x8000;

	const TInt  KMaxHeapSize = 0x80000;

	_LIT(KCallThreadName, "OutgoingCallThreadWithPublishSubscribe");

	_LIT(KOutgoingThreadSuccess, "Kill");

	//

	// Make sure watchers are stopped and unloaded before running this test

	// This forces SIMTSY to be loaded again

	//

	StopWatcher();

	SetSimTsyTestNumberL(3);

	//

	// The following is required when running all the tests in "batch" mode.

	// Since the property persists and the "Call Thread" uses the

	// KUidCurrentCall>=KErrNone as an indicator that the Watchers are loaded,

	// its important to ensure that it starts out with an error condition.

	// This will be reset by the Indicator Watcher.

	//

	TInt  initialState;

	User::LeaveIfError(RProperty::Get(KUidSystemCategory,KUidCurrentCall.iUid,initialState));

	INFO_PRINTF2(_L("Initial Call Status is %d"), initialState);

	if (initialState >= KErrNone)

		{

		User::LeaveIfError(RProperty::Set(KUidSystemCategory,KUidCurrentCall.iUid,KErrUnknown));

		}

	StartWatcher();

	//

	// Start an outgoing call in a separate thread.

	//

	RThread  thread;

	TRequestStatus  status;

	TInt  res;

	res = thread.Create(KCallThreadName, OutgoingCallThreadFunction,

						KStackSize, KHeapSize, KMaxHeapSize, this);

	TESTCHECKL(res, KErrNone)

	thread.Logon(status);

	thread.Resume();

	//

	// Monitor the Current Call Status through each state...

	//

	TInt  state;

	TRequestStatus  localStatus;

	RProperty localProperty;

	//-- attach and subscribe to KUidCurrentCall property

	res = localProperty.Attach(KUidSystemCategory,KUidCurrentCall.iUid);

	TESTCHECKL(res, KErrNone);

	localProperty.Subscribe(localStatus);  

	User::WaitForRequest(localStatus);			

	res = localProperty.Get(state);

	localProperty.Subscribe(localStatus);

	TESTCHECKL(res, KErrNone);

	INFO_PRINTF2(_L("Current Call Status is %d"), state);

	TESTCHECK(state, ESACallNone);

	User::WaitForRequest(localStatus);		

	res = localProperty.Get(state);

	localProperty.Subscribe(localStatus);	

	TESTCHECKL(res, KErrNone);

	INFO_PRINTF2(_L("Current Call Status is %d"), state);

	TESTCHECK(state, ESACallDialling);

	User::WaitForRequest(localStatus);		

	res = localProperty.Get(state);

	localProperty.Subscribe(localStatus);	

	TESTCHECKL(res, KErrNone);

	INFO_PRINTF2(_L("Current Call Status is %d"), state);

	TESTCHECK(state, ESACallAlerting);

	User::WaitForRequest(localStatus);		

	res = localProperty.Get(state);

	localProperty.Subscribe(localStatus);	

	TESTCHECKL(res, KErrNone);

	INFO_PRINTF2(_L("Current Call Status is %d"), state);

	TESTCHECK(state, ESACallVoice);

	User::WaitForRequest(localStatus);		

	res = localProperty.Get(state);

	localProperty.Subscribe(localStatus);	

	TESTCHECKL(res, KErrNone);

	INFO_PRINTF2(_L("Current Call Status is %d"), state);

	TESTCHECK(state, ESACallDisconnecting);

	User::WaitForRequest(localStatus);		

	res = localProperty.Get(state);

	TESTCHECKL(res, KErrNone);

	INFO_PRINTF2(_L("Current Call Status is %d"), state);

	TESTCHECK(state, ESACallNone);

	User::WaitForRequest(status);

	TESTCHECK(status.Int(), KErrNone);

	TESTCHECKSTR(thread.ExitCategory(), KOutgoingThreadSuccess);

	TESTCHECK(thread.ExitReason(), KErrNone);	

	TESTCHECK(thread.ExitType(), EExitKill);

	thread.Close();

	CheckSimTsyTestNumberL(3);

 	return TestStepResult();

	} // CTelWatchersIntTestOutgoingCallStatusWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersIntTestIncomingCallStatusWithPublishSubscribe::CTelWatchersIntTestIncomingCallStatusWithPublishSubscribe()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestIncomingCallStatusWithPublishSubscribe"));

	} // CTelWatchersIntTestIncomingCallStatusWithPublishSubscribe::CTelWatchersIntTestIncomingCallStatusWithPublishSubscribe