// 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 Unit Test main test code.

// 

//

/**

 @file

*/

#include <e32uid.h>

#include <f32file.h>

#include <bafindf.h>

#include <cdbcols.h>

#include "indicatorwatcher.h"

#include "signalstrengthwatcher.h"

#include "TE_TelWatchersUnitBase.h"

#include "TE_TelWatchersUnitTest.h"

//

// Constants...

//

const TInt  KExpectedCallStateChanges(4);

const TInt  KExpectedBatteryChargerStateChanges(4);

const TInt  KExpectedNetworkAvailabilityStateChanges(4);

const TInt  KSimulatedCommDBChanges(10);

/**

 *  Each test step initialises it's own name

 */

CTelWatchersUnitTestCallStateChangesWithPublishSubscribe::CTelWatchersUnitTestCallStateChangesWithPublishSubscribe()

	{

	//

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

	// the script file.

	//

	SetTestStepName(_L("TestCallStateChangesWithPublishSubscribe"));

	} // CTelWatchersUnitTestCallStateChangesWithPublishSubscribe::CTelWatchersUnitTestCallStateChangesWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersUnitTestCallStateChangesWithPublishSubscribe::~CTelWatchersUnitTestCallStateChangesWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersUnitTestCallStateChangesWithPublishSubscribe::~CTelWatchersUnitTestCallStateChangesWithPublishSubscribe

/**

 *  This test monitors the call state notifications and checks they

 *  are as expected and valid.

 */	

enum TVerdict CTelWatchersUnitTestCallStateChangesWithPublishSubscribe::doTestStepL()

	{

	SetSimTsyTestNumberL(0);

	RProperty propCurrCallState; //- property that reflects current call state	

	TInt propVal = KErrUnknown;  //- value of the property

	INFO_PRINTF2(_L("Wait for %d call state changes with publish and subscribe"),

		         KExpectedCallStateChanges);

	//-- attach to KUidCurrentCall property

	TESTL(propCurrCallState.Attach(KUidSystemCategory,KUidCurrentCall.iUid) == KErrNone);

	//

	// Install the Indicator and Signal Strength watcher...

	//

	TInt dummyWatcherParams;

	CIndicatorWatcher*  indicatorWatcher = CIndicatorWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(indicatorWatcher);

	CSignalStrengthWatcher*  signalStrengthWatcher = CSignalStrengthWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(signalStrengthWatcher);

	//

	// Prepare indicator watcher to return random call state

	// values...

	//

  	TESTL(RProperty::Set(KUidSystemCategory, KUidTestProp_CallStateChange.iUid, 0) == KErrNone);

	//

	// Wait for the change events...

	//

	CWatcherObserverPS* watcher = new(ELeave) CWatcherObserverPS;

	CleanupStack::PushL(watcher);

	watcher->BindProperty(&propCurrCallState);

	TInt  counter;

	for (counter = 0;  counter < KExpectedCallStateChanges;  counter++)

		{

		//

		// Prepares a notify request and starts the scheduler. Stops the

		// scheduler when notify is detected.

		//

        watcher->WaitForPropertyChangeL();

        //-- get property value after it has been updated

       TESTL(watcher->GetPropertyValue(propVal) == KErrNone);

		//

		// Print the state...

		//

		switch (propVal)

			{

			case ESACallNone:

				{

				INFO_PRINTF1(_L("  Call None."));

				}

				break;

			case ESACallVoice:

				{

				INFO_PRINTF1(_L("  Call Voice."));

				}

				break;

			case ESACallFax:

				{

				INFO_PRINTF1(_L("  Call Fax."));

				}

				break;

			case ESACallData:

				{

				INFO_PRINTF1(_L("  Call Data."));

				}

				break;

			case ESACallAlerting:

				{

				INFO_PRINTF1(_L("  Call Alerting."));

				}

				break;

			case ESACallRinging:

				{

				INFO_PRINTF1(_L("  Call Ringing."));

				}

				break;

			case ESACallAlternating:

				{

				INFO_PRINTF1(_L("  Call Alternating."));

				}

				break;

			default:

				{

				INFO_PRINTF2(_L("Failed: Unknown state returned (%d)!"), propVal);

		        SetTestStepResult(EFail);

				}

				break;

			}

		}

	CleanupStack::PopAndDestroy(watcher);

	CleanupStack::PopAndDestroy(signalStrengthWatcher);

	CleanupStack::PopAndDestroy(indicatorWatcher);

	return TestStepResult();

	} // CTelWatchersUnitTestCallStateChangesWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe::CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe()

	{

	//

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

	// the script file.

	//

	SetTestStepName(_L("TestBatteryChargerChangesWithPublishSubscribe"));

	} // CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe::CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe::~CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe::~CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe

/**

 *  This test monitors the battery charger notifications and checks they

 *  are as expected and valid.

 */	

enum TVerdict CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe::doTestStepL()

	{

	SetSimTsyTestNumberL(0);

	RProperty propChargerState;  //- property that reflects phone charger state

	TInt propVal = KErrUnknown;  //- value of the property

	INFO_PRINTF2(_L("Wait for %d battery charger changes with publish and subscribe"),

		         KExpectedBatteryChargerStateChanges);

	//-- attach to KUidChargerStatus property

	TESTL(propChargerState.Attach(KUidSystemCategory,KUidChargerStatus.iUid) == KErrNone);

	//

	// Install the Indicator and Signal Strength watcher...

	//

    TInt dummyWatcherParams;

	CIndicatorWatcher*  indicatorWatcher = CIndicatorWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(indicatorWatcher);

	CSignalStrengthWatcher*  signalStrengthWatcher = CSignalStrengthWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(signalStrengthWatcher);

	//

	// Prepare indicator watcher to return random battery values...

	//

	//

	TESTL(RProperty::Set(KUidSystemCategory, KUidTestProp_CallStateChange.iUid, 1) == KErrNone);

	//

	// Wait for the change events...

	//	

	CWatcherObserverPS* watcher = new(ELeave) CWatcherObserverPS;

	CleanupStack::PushL(watcher);

	watcher->BindProperty( &propChargerState );

	TInt counter;

	for (counter = 0;  counter < KExpectedBatteryChargerStateChanges;  counter++)

		{

		//

		// Prepares a notify request and starts the scheduler. Stops the scheduler

		// when notify is detected.

		//

		watcher->WaitForPropertyChangeL();

        //-- get property value after it has been updated

        TESTL(watcher->GetPropertyValue(propVal) == KErrNone);

		//

		// Print state...

		//

		switch (propVal)

			{

			case ESAChargerConnected:

				{

				INFO_PRINTF1(_L("  Charger connected."));

				}

				break;

			case ESAChargerDisconnected:

				{

				INFO_PRINTF1(_L("  Charger disconnected."));

				}

				break;

			case ESAChargerNotCharging:

				{

				INFO_PRINTF1(_L("  Not charging."));

				}

				break;

			default:

				{

				INFO_PRINTF2(_L("Failed: Unknown state returned (%d)!"), propVal);

		        SetTestStepResult(EFail);

				}

				break;

			}

		}

	CleanupStack::PopAndDestroy(watcher);

	CleanupStack::PopAndDestroy(signalStrengthWatcher);

	CleanupStack::PopAndDestroy(indicatorWatcher);

	return TestStepResult();

	} // CTelWatchersUnitTestBatteryChargerChangesWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe::CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe()

	{

	//

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

	// the script file.

	//

	SetTestStepName(_L("TestNetworkAvailabilityChangesWithPublishSubscribe"));

	} // CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe::CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe::~CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe::~CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe

/**

 *  This test monitors the network availablity notifications and checks they

 *  are as expected and valid.

 */	

enum TVerdict CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe::doTestStepL()

	{

	SetSimTsyTestNumberL(0);

	RProperty propNetworkState;  //- property that reflects phone charger state

	TInt propVal = KErrUnknown;  //- value of the property

	INFO_PRINTF2(_L("Wait for %d network availability changes with publish and subscribe"),

		         KExpectedNetworkAvailabilityStateChanges);

	//-- attach to KUidCurrentCall property

	TESTL(propNetworkState.Attach(KUidSystemCategory,KUidNetworkStatus.iUid) == KErrNone);

	//

	// Install the Indicator and Signal Strength watcher...

	//

    TInt dummyWatcherParams;

	CIndicatorWatcher*  indicatorWatcher = CIndicatorWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(indicatorWatcher);

	CSignalStrengthWatcher*  signalStrengthWatcher = CSignalStrengthWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(signalStrengthWatcher);

	//

	// Prepare indicator watcher to return random network state

	// values...

	//

	TESTL(RProperty::Set(KUidSystemCategory, KUidTestProp_CallStateChange.iUid, 2) == KErrNone);

	//

	// Wait for the change events...

	//

	CWatcherObserverPS* watcher = new(ELeave) CWatcherObserverPS;

	CleanupStack::PushL(watcher);

	watcher->BindProperty( &propNetworkState );

	TInt counter;

	for (counter = 0;  counter < KExpectedNetworkAvailabilityStateChanges;  counter++)

		{

		//

		// Prepares a notify request and starts the scheduler. Stops the

		// scheduler when notify is detected.

		//

		watcher->WaitForPropertyChangeL();

        //-- get property value after it has been updated

        TESTL(watcher->GetPropertyValue(propVal) == KErrNone);

		//

		// Print state...

		//

		switch(propVal)

			{

			case ESANetworkAvailable:

				{

				INFO_PRINTF1(_L("  Network available."));

				}

				break;

			case ESANetworkUnAvailable:

				{

				INFO_PRINTF1(_L("  Network unavailable."));

				}

				break;

			default:

				{

				INFO_PRINTF2(_L("Failed: Unknown state returned (%d)!"), propVal);

		        SetTestStepResult(EFail);

				}

				break;

			}

		}

	CleanupStack::PopAndDestroy(watcher);

	CleanupStack::PopAndDestroy(signalStrengthWatcher);

	CleanupStack::PopAndDestroy(indicatorWatcher);

	return TestStepResult();

	} // CTelWatchersUnitTestNetworkAvailabilityChangesWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe::CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe()

	{

	//

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

	// the script file.

	//

	SetTestStepName(_L("TestSimulteCommDBModemChangeWithPublishSubscribe"));

	} //CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe::CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe::~CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe::~CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe

/**

 *  This test issues a number of CommDB table update requests to the Watcher and

 *  checks that the CommDB table is re-read.

 */	

enum TVerdict CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe::doTestStepL()

	{	

	SetSimTsyTestNumberL(0);

	INFO_PRINTF2(_L("Simulate %d CommDB default modem changes with publish and subscribe"),

		         KSimulatedCommDBChanges);

	RProperty propMdmRecordChanged;   //-- modem record change property (debug only)

	RProperty propMdmTableRefreshed;  //-- modem table re-read property (debug only)

	TESTL(propMdmRecordChanged.Attach(KUidSystemCategory, KUidTestProp_ModemRecordChanged.iUid) == KErrNone);

	TESTL(propMdmTableRefreshed.Attach(KUidSystemCategory, KUidTestProp_ModemTableRefreshed.iUid) == KErrNone);

	//

	// Install the Indicator and Signal Strength watcher...

	//

    TInt dummyWatcherParams;

	CIndicatorWatcher*  indicatorWatcher = CIndicatorWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(indicatorWatcher);

	CSignalStrengthWatcher*  signalStrengthWatcher = CSignalStrengthWatcher::NewL((TAny*)&dummyWatcherParams);

	CleanupStack::PushL(signalStrengthWatcher);

	//

	// Allow a few seconds for the Active Objects to start...

	//

	PauseToRunActiveSchedulerL(10);

	//

	// Wait for the change events...

	//

	CWatcherObserverPS* watcher = new(ELeave) CWatcherObserverPS;

	CleanupStack::PushL(watcher);

	TInt  counter;

	for (counter = 0;  counter < KSimulatedCommDBChanges;  counter++)

		{

		//

		// Send some comm db modem record change events

		//

		TTime  time;

		time.UniversalTime();

        TESTL(RProperty::Set(KUidSystemCategory, KUidCommDbModemPhoneServicesAndSMSChange.iUid, I64LOW(time.Int64())) == KErrNone );

		//

		// Now wait for an ack that the change was spotted...

		//

        watcher->BindProperty(&propMdmRecordChanged);

        watcher->WaitForPropertyChangeL();

		INFO_PRINTF1(_L("  CommDB change has been spotted."));

		//

		// Now wait for an ack that the modem table has been re-read ok

		//

        watcher->BindProperty(&propMdmTableRefreshed);

        watcher->WaitForPropertyChangeL();

		INFO_PRINTF1(_L("  Modem table has been re-read."));

		//

		// Now wait a few seconds before trying again

		//

		PauseToRunActiveSchedulerL(10);

		}

	CleanupStack::PopAndDestroy(watcher);

	CleanupStack::PopAndDestroy(signalStrengthWatcher);

	CleanupStack::PopAndDestroy(indicatorWatcher);

	return TestStepResult();

	} // CTelWatchersUnitTestSimulteCommDBModemChangeWithPublishSubscribe::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe::CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe()

	{

	//

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

	// the script file.

	//

	SetTestStepName(_L("TestCommDBChangeWhenWatcherDisabledWithPublishSubscribe"));

	} // CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe::CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe

/**

 *  Simple destructor.

 */

CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe::~CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe()

	{

	// NOP

	} // CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe::~CTelWatchersUnitTestCommDBChangeWhenWatcherDisabledWithPublishSubscribe

/**

 *  This test checks that the Watcher notices a CommDB change whilst the Watcher

 *  are disabled.