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

// The TEFUnit test suite for BroadcastMessaging in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsybroadcastmessagingfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

#include <mmretrieve.h>

#include "cctsyactiveretriever.h"

#include <ctsy/serviceapi/cmmsmsutility.h>

CTestSuite* CCTsyBroadcastMessagingFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetFilterSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetLanguageFilter0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetLanguageFilter0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyLanguageFilterChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyBroadcastIdListChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetCaps0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetCaps0003L);

	END_SUITE;

	}

void CCTsyBroadcastMessagingFU::FillInBroadcastIdListL(CMobilePhoneBroadcastIdList& aList)

	{

	RMobileBroadcastMessaging::TMobileBroadcastIdEntryV1 entry;

	entry.iId = 7;

	aList.AddEntryL(entry);

	entry.iId = 17;

	aList.AddEntryL(entry);

	entry.iId = 37;

	aList.AddEntryL(entry);

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::StoreBroadcastIdListL

@SYMTestPriority High

@SYMTestActions Invokes RMobileBroadcastMessaging::StoreBroadcastIdListL

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0001L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

	TRequestStatus reqStatus;

	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(idList);

	RMobileBroadcastMessaging::TMobileBroadcastIdType type

	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

	                                             expectLtsyData(idList, type);

	FillInBroadcastIdListL(*idList);

	expectLtsyData.SerialiseL(data); 

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

	// TEST A: failure to dispatch request to LTSY

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

    messaging.StoreBroadcastIdListL(reqStatus, idList, type);

	User::WaitForRequest(reqStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

	iMockLTSY.NotifyTerminated(reqStatus);

	iMockLTSY.CompleteL(EMobileBroadcastMessagingStoreIdList, KErrNone);

	User::WaitForRequest(reqStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this); // idList, messaging, data, this

	}

/**

@SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileBroadcastMessaging::StoreBroadcastIdListL

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RMobileBroadcastMessaging::StoreBroadcastIdListL

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0002L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

	TRequestStatus reqStatus;

	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(idList);

	RMobileBroadcastMessaging::TMobileBroadcastIdType type

	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

	                                             expectLtsyData(idList, type);

	FillInBroadcastIdListL(*idList);

	expectLtsyData.SerialiseL(data); 

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

	// Test cancelling of RMobileBroadcastMessaging::StoreBroadcastIdListL

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

    messaging.StoreBroadcastIdListL(reqStatus, idList, type);

	messaging.CancelAsyncRequest(EMobileBroadcastMessagingStoreIdList);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this); // idList, messaging, data, this

	}

/**

@SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0003

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::StoreBroadcastIdListL with bad parameter data

@SYMTestPriority High

@SYMTestActions Invokes RMobileBroadcastMessaging::StoreBroadcastIdListL with bad parameter data

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0003L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

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

	// Test A: Test passing wrong version of parameters to

	// RMobileBroadcastMessaging::StoreBroadcastIdListL

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

	TRequestStatus reqStatus;

	CMobilePhoneBroadcastIdList* idList(NULL);

	messaging.StoreBroadcastIdListL(reqStatus, idList, RMobileBroadcastMessaging::EGsmBroadcastId);

	// should never get here because of etel panic

	// so if it gets test fails with the assert below

	ASSERT_TRUE(EFalse);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNone, reqStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(2, this); // messaging, this

	}

/**

@SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileBroadcastMessaging::StoreBroadcastIdListL

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RMobileBroadcastMessaging::StoreBroadcastIdListL

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0004L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

	TRequestStatus reqStatus;

	TRequestStatus reqStatus2;

	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(idList);

	CMobilePhoneBroadcastIdList* idList2 = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(idList2);

	RMobileBroadcastMessaging::TMobileBroadcastIdType type

	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

	                                             expectLtsyData(idList, type);

	FillInBroadcastIdListL(*idList);

	expectLtsyData.SerialiseL(data); 

	// Open second client

	RTelServer telServer2;

	TInt ret = telServer2.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer2);

	RMobilePhone phone2;

	ret = phone2.Open(telServer2, KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone2);

	RMobileBroadcastMessaging messaging2;

	err = messaging2.Open(phone2);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging2);

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

	// Test A: Test multiple clients requesting RMobileBroadcastMessaging::StoreBroadcastIdListL

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

    messaging.StoreBroadcastIdListL(reqStatus, idList, RMobileBroadcastMessaging::EGsmBroadcastId);

	messaging2.StoreBroadcastIdListL(reqStatus2, idList2, RMobileBroadcastMessaging::EGsmBroadcastId);

	User::WaitForRequest(reqStatus);

	User::WaitForRequest(reqStatus2);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

	ASSERT_EQUALS(KErrNotSupported, reqStatus2.Int());

	CleanupStack::PopAndDestroy(8, this); // messaging2, phone2, telServer2, idList2, idList, messaging, data, this

	}

/**

@SYMTestCaseID BA-CTSY-BRMSG-BRM-0005

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::StoreBroadcastIdListL with timeout

@SYMTestPriority High

@SYMTestActions Invokes RMobileBroadcastMessaging::StoreBroadcastIdListL and tests for timeout

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0005L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

	TRequestStatus reqStatus;

	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(idList);

	RMobileBroadcastMessaging::TMobileBroadcastIdType type

	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

	                                             expectLtsyData(idList, type);

	FillInBroadcastIdListL(*idList);

	expectLtsyData.SerialiseL(data); 

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

	// Test A: Test timeout of RMobileBroadcastMessaging::StoreBroadcastIdListL

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

	iMockLTSY.ExpectL(EMobileBroadcastMessagingStoreIdList, data);

	messaging.StoreBroadcastIdListL(reqStatus, idList, type);

	User::WaitForRequest(reqStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

	CleanupStack::PopAndDestroy(4, this); // idList, messaging, data, this

	}

/**

@SYMTestCaseID BA-CTSY-BRMSG-RMPBLN-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneBroadcastIdList::Start

@SYMTestPriority High

@SYMTestActions Invokes CRetrieveMobilePhoneBroadcastIdList::Start

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStart0001L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList =

	                                    CRetrieveMobilePhoneBroadcastIdList::NewL(messaging);

	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever(*retrieveMobilePhoneBroadcastIdList);

	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever);

	// prepare mockLtsy data

	RMobileBroadcastMessaging::TMobileBroadcastIdType type(RMobileBroadcastMessaging::EGsmBroadcastId);

	TMockLtsyData1<RMobileBroadcastMessaging::TMobileBroadcastIdType> expectLtsyData(type);

	RBuf8 expData;

	CleanupClosePushL(expData);

	expectLtsyData.SerialiseL(expData);

	CMobilePhoneBroadcastIdList* completeList = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(completeList);

	FillInBroadcastIdListL(*completeList);

	RBuf8 completeData;

	CleanupClosePushL(completeData);

	TSerializer<CMobilePhoneBroadcastIdList>::SerialiseL(*completeList, completeData);

	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(), type);

	activeMobilePhoneBroadcastIdListRetriever.Activate();

	scheduler.StartScheduler();

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrNotSupported, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

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

	// TEST E: Unsolicited completion of CAsyncRetrieveAuthorizationInfo::Start

	// from LTSY.

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

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(EMobileBroadcastMessagingGetIdListPhase1, KErrNone, completeData);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(5, &messaging); // list, completeData, completeList, expData, retrieveMobilePhoneBroadcastIdList, messaging

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CTSY-BRMSG-RMPBLN-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of CRetrieveMobilePhoneBroadcastIdList::Start

@SYMTestPriority High

@SYMTestActions Invokes cancelling of CRetrieveMobilePhoneBroadcastIdList::Start

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyBroadcastMessagingFU::TestStart0002L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	RMobileBroadcastMessaging messaging;

	TInt err = messaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(messaging);

	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList =

	                                      CRetrieveMobilePhoneBroadcastIdList::NewL(messaging);

	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever(*retrieveMobilePhoneBroadcastIdList);

	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever);

	// prepare mockLtsy data

	RMobileBroadcastMessaging::TMobileBroadcastIdType type(RMobileBroadcastMessaging::EGsmBroadcastId);

	TMockLtsyData1<RMobileBroadcastMessaging::TMobileBroadcastIdType> expectLtsyData(type);

	RBuf8 expData;

	CleanupClosePushL(expData);

	expectLtsyData.SerialiseL(expData);

	CMobilePhoneBroadcastIdList* completeList = CMobilePhoneBroadcastIdList::NewL();

	CleanupStack::PushL(completeList);

	FillInBroadcastIdListL(*completeList);

	RBuf8 completeData;

	CleanupClosePushL(completeData);

	TSerializer<CMobilePhoneBroadcastIdList>::SerialiseL(*completeList, completeData);

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

	// Test cancelling of CRetrieveMobilePhoneBroadcastIdList::Start

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

	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(), type);

	activeMobilePhoneBroadcastIdListRetriever.Activate(CActiveRetriever::ECaseGeneralCancelCase);

	scheduler.StartScheduler();

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrCancel, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(),

	                                          RMobileBroadcastMessaging::EGsmBroadcastId);

	activeMobilePhoneBroadcastIdListRetriever.Activate(CActiveRetriever::ECasePhase2Cancel);

	scheduler.StartScheduler();