// 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:

// Utility functions for Sms Stack test harnesses

// 

//

/**

 @file

*/

#include "smsstacktestutilities.h"

#include <commsdattypesv1_1.h>

#include <commsdattypesv1_1_internal.h>

#include <logcli.h>

#include <e32math.h>

#include <e32test.h>

#include <f32file.h>

#include <logwraplimits.h>

#include "smsustrm.h"

#include "Gsmumsg.h"

#include "smsuaddr.H"

#include "gsmubuf.h"

#include "smspdudb.h"

#include "SmsuTimer.h"

#include "smsstacklog.h"

using namespace CommsDat;

// Check a boolean is true

#define LOCAL_CHECKPOINT(a) iTestStep->testBooleanTrue((a), (TText8*)__FILE__, __LINE__)

// Check a boolean is true if not return error code b

#define LOCAL_CHECKPOINT_CODE(a, b) iTestStep->testBooleanTrueWithErrorCode((a), (b), (TText8*)__FILE__, __LINE__)

#define LOCAL_CHECKPOINT_COMPAREL(p1, p2, p3) iTestStep->TestCheckPointCompareL((p1), (p2), (p3), (TText8*)__FILE__, __LINE__)

// TestExecute style Printf

#define PRINTF1(p1)							iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1))

#define PRINTF2(p1, p2)						iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2))

#define PRINTF3(p1, p2, p3)					iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3))

#define PRINTF4(p1, p2, p3, p4)				iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4))

#define PRINTF5(p1, p2, p3, p4, p5)			iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5))

#define PRINTF6(p1, p2, p3, p4, p5, p6)		iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6))

#define PRINTF7(p1, p2, p3, p4, p5, p6, p7)	iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7))

class CTSmsRegTstActive : public CActive

	{

public:

	CTSmsRegTstActive();

	~CTSmsRegTstActive();

	void StartL();

protected:

	void DoCancel();

	void RunL();

	};

CTSmsRegTstActive::CTSmsRegTstActive():

	CActive(0)

	{

	CActiveScheduler::Add(this);

	}

CTSmsRegTstActive::~CTSmsRegTstActive()

	{

	Cancel();

	}

void CTSmsRegTstActive::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrNone);

	}

void CTSmsRegTstActive::StartL()

	{

	SetActive();

	}

void CTSmsRegTstActive::RunL()

	{

	CActiveScheduler::Stop();

	}

EXPORT_C CSmsStackTestUtils* CSmsStackTestUtils::NewL(CTestStep* aTestStep, RFs& aFs)

	{

	CSmsStackTestUtils* self = new (ELeave) CSmsStackTestUtils(aTestStep, aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSmsStackTestUtils::ConstructL()

	{

	iCharConv = CCnvCharacterSetConverter::NewL();

	}

EXPORT_C CSmsStackTestUtils::~CSmsStackTestUtils()

	{

	delete iCharConv;

	}

CSmsStackTestUtils::CSmsStackTestUtils(CTestStep* aTestStep, RFs& aFs)

: iTestStep(aTestStep), iFs(aFs)

	{

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketLC(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddrFamily aFamily)

/**

 *  Initialise an RSocket for SMS

 *  @note aSocket is pushed to CleanupStack.

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aFamily The sms address family

 */

	{

	OpenSmsSocketL(aSocketServer, aSocket, aFamily);

	CleanupClosePushL(aSocket);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketL(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddrFamily aFamily)

/**

 *  Initialise an RSocket for SMS, aSocket is NOT pushed to CleanupStack.

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aFamily The sms address family

 */

	{

	TSmsAddr smsaddr;

	smsaddr.SetSmsAddrFamily(aFamily);

	OpenSmsSocketL(aSocketServer, aSocket, smsaddr);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketLC(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddr& aSmsAddr)

/**

 *  Initialise an RSocket for SMS.

 *  @note aSocket is pushed to CleanupStack

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aSmsAddr The sms address to bind to

 */

	{

	OpenSmsSocketL(aSocketServer, aSocket, aSmsAddr);

	CleanupClosePushL(aSocket);

	}

EXPORT_C void CSmsStackTestUtils::OpenSmsSocketL(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddr& aSmsAddr)

/**

 *  Initialise an RSocket for SMS, aSocket is NOT pushed to CleanupStack.

 *  @param aSocketServer reference to the socket server object

 *  @param aSocket The socket that will be opened

 *  @param aSmsAddr The sms address to bind to

 */

	{

	TInt ret=aSocket.Open(aSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);

	PRINTF2(_L("Socket Open Return Value : %d"),ret);

	LOCAL_CHECKPOINT(ret == KErrNone);

	CleanupClosePushL(aSocket);

	ret=aSocket.Bind(aSmsAddr);

	PRINTF2(_L("Socket Bind Return Value : %d"),ret);

	LOCAL_CHECKPOINT(ret == KErrNone);

	TProtocolDesc desc;

	aSocket.Info(desc);

	PRINTF2(_L("Protocol name: %S"), &desc.iName);

    TTimeIntervalMicroSeconds32 InitPause=9000000;  //Required Pause to Allow SMSStack to Complete its Async Init

    User::After(InitPause);                         //call to the TSY and finish its StartUp.

	CleanupStack::Pop(&aSocket);

	}

EXPORT_C void CSmsStackTestUtils::SendSmsAndChangeBearerL(CSmsMessage* aSms, RSocket& aSocket, RMobileSmsMessaging::TMobileSmsBearer aBearer)

/**

 *  Stream aSms out to the socket server. The idea is to change bearer midway through

 *  sending the PDUs making up the complete message.

 *  @param aSms contains the sms tpdu that will be streamed to the sms stack

 *  @param aSocket is used to stream the aSms to the sms stack

 *  @param aBearer Bearer setting that is changed to CommDb

 *  @leave Leaves if streaming the message to the socket server doesn't succeed

 *  @leave Leaves if sending is completed with error code

 */

	{

	RSmsSocketWriteStream writestream(aSocket);

	TRAPD(ret,writestream << *aSms);

	LOCAL_CHECKPOINT(ret == KErrNone);

	TRAP(ret,writestream.CommitL());

	LOCAL_CHECKPOINT(ret == KErrNone);

    // Create comms database object

    CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

    CleanupStack::PushL(db);

 	//Send message and change bearer

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

	aSocket.Ioctl(KIoctlSendSmsMessage, status, &sbuf, KSolSmsProv);

	//Wait couple of seconds to ensure first pdus of message have been sent

	User::After(2500000);

    // Change bearer

    CMDBField<TUint32>* smsBearerField = new(ELeave) CMDBField<TUint32>(KCDTIdSMSBearer);

    CleanupStack::PushL(smsBearerField);

    smsBearerField->SetRecordId(1); //it's GlobalSettingsRecord

    *smsBearerField = aBearer;

    smsBearerField->ModifyL(*db);

    CleanupStack::PopAndDestroy(smsBearerField);

    CleanupStack::PopAndDestroy(db);

	User::WaitForRequest(status);

	PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"), status.Int());

	LOCAL_CHECKPOINT(status.Int() == KErrNone);

	CSmsBuffer& smsbuffer = (CSmsBuffer&)aSms->Buffer();

	TInt len = smsbuffer.Length();

	HBufC* hbuf = HBufC::NewL(len);

	TPtr ptr = hbuf->Des();

	smsbuffer.Extract(ptr,0,len);

	PRINTF2(_L("SMS contains %d characters"),len);

	delete hbuf;

	}

EXPORT_C void CSmsStackTestUtils::ChangeBearerL(RMobileSmsMessaging::TMobileSmsBearer aBearer)

/**

Change the bearer in CommDB global settings.

@param aBearer The new bearer setting.

@return none

*/

	{

    // Start a CommDB session

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

    CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

    CleanupStack::PushL(db);

    // Change bearer in global settings

    CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

    TRAPD(err, globalSettingsRecord.LoadL(*db));

    if (err != KErrNone)

        {

        PRINTF2(_L("Could not load global settings. Error = %d\n"), err);

        User::Leave(err);

        }

    ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer = aBearer;

    globalSettingsRecord.ModifyL(*db);

    PRINTF2(_L("Setting bearer in global settings to %d\n"), aBearer); 

    CleanupStack::PopAndDestroy(db);

	}

EXPORT_C void CSmsStackTestUtils::GetBearerL(RMobileSmsMessaging::TMobileSmsBearer& aBearer)

/**

Get the bearer from CommDB global settings.

@param aBearer The bearer setting retrieved from global settings.

@return none

*/

    {

    // Start a CommDB session

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

    CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

    CleanupStack::PushL(db);

    // Load global settings

    CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);

    TRAPD(err, globalSettingsRecord.LoadL(*db));

    if (err != KErrNone)

        {

        PRINTF2(_L("Could not load global settings. Error = %d\n"), err);

        User::Leave(err);

        }

    TInt tempBearer = ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer;

    aBearer = static_cast<RMobileSmsMessaging::TMobileSmsBearer>(tempBearer);

    PRINTF2(_L("Got bearer from CommDB. Bearer = %d\n"), aBearer);

    CleanupStack::PopAndDestroy(db);

    }

EXPORT_C void CSmsStackTestUtils::DisableLogging()

 	{

 	CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();

 	CleanupStack::PushL(testActive);

 	testActive->StartL();	

 	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

 	CleanupStack::PushL(logWrapper);

 	CLogClient& logClient = static_cast<CLogClient&>(logWrapper->Log());

 	TLogConfig config;

 	logClient.GetConfig(config, testActive->iStatus);

 	CActiveScheduler::Start();

 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

 	// Disable logging

 	config.iMaxEventAge = 0;

 	config.iMaxLogSize = 0;

 	config.iMaxRecentLogSize = 0;

 	testActive->StartL();

 	logClient.ChangeConfig(config, testActive->iStatus);

 	CActiveScheduler::Start();

 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

 	CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper

	}

 EXPORT_C void CSmsStackTestUtils::EnableLogging()

    {

    CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();

    CleanupStack::PushL(testActive);

    testActive->StartL();	

    CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

    CleanupStack::PushL(logWrapper);

    CLogClient& logClient = static_cast<CLogClient&> (logWrapper->Log());

    TLogConfig config;

    logClient.GetConfig(config, testActive->iStatus);

    CActiveScheduler::Start();

    LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

    // Enable logging - default values

    config.iMaxEventAge = 2592000;

    config.iMaxLogSize  = 1000; 

    config.iMaxRecentLogSize = 20; 

    testActive->StartL();	

    logClient.ChangeConfig(config, testActive->iStatus);

    CActiveScheduler::Start();

    LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

    CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper

    }		

EXPORT_C void CSmsStackTestUtils::GetLogEventL(CLogEvent& aLogEvent, TInt aLogServerId)

/**

 *  Get SMS log event from event logger.

 *  @param aLogEvent reference to the CLogEvent object

 *  @param aLogServerId number of log event

 */

	{

	CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();

	CleanupStack::PushL(testActive);

	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

	CleanupStack::PushL(logWrapper);

	aLogEvent.SetId(aLogServerId);

	testActive->StartL();

	logWrapper->Log().GetEvent(aLogEvent,testActive->iStatus);

	CActiveScheduler::Start();

	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

    CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper

	}

EXPORT_C TLogId CSmsStackTestUtils::AddLogEventL(CSmsMessage& aSmsMessage,TLogSmsPduData& aSmsPDUData)

/**

 *  Add SMS log event to the event logger.

 *  @param aSmsMessage SM mesage

 *  @param aLogSmsPduData initialised structure  with data relevant to logging

 */

	{

	CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();

	CleanupStack::PushL(testActive);

	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);

	CleanupStack::PushL(logWrapper);

	TLogId id=NULL;

	if(logWrapper->ClientAvailable())

	{

		testActive->StartL();

		CLogEvent* logevent=CLogEvent::NewL();

		CleanupStack::PushL(logevent);

		TBuf<KLogMaxDirectionLength> direction;

		User::LeaveIfError(logWrapper->Log().GetString(direction,R_LOG_DIR_OUT));

		logevent->SetDirection(direction);

		logevent->SetEventType(KLogShortMessageEventTypeUid);

		logevent->SetNumber(aSmsMessage.ToFromAddress());

		logevent->SetSubject(_L("test"));

		logevent->SetStatus(_L("status"));

		TPckg<TLogSmsPduData> packeddata(aSmsPDUData);

		logevent->SetDataL(packeddata);

		PRINTF2(_L("iStatus is %d"), testActive->iStatus.Int());

		logWrapper->Log().AddEvent(*logevent,testActive->iStatus);

		CActiveScheduler::Start();

		PRINTF2(_L("iStatus is %d"), testActive->iStatus.Int());

		LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);

		id=logevent->Id();

		CleanupStack::PopAndDestroy(logevent);

	}

    CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper

	return id;

	}

EXPORT_C void CSmsStackTestUtils::CopyConfigFileL(const TDesC& aFromSmsConfigFile, CSmsPduDatabase* aPduDb)

	{

	PRINTF3(_L("Copying %S to %S..."), &aFromSmsConfigFile, &KSimTsyConfigFileName);

	TBool createdDb = EFalse;

	if (aPduDb == NULL)

		{

		aPduDb = CSmsPduDatabase::NewL(iFs);

		CleanupStack::PushL(aPduDb);

		createdDb = ETrue;

		}

	aPduDb->RewriteFileL(aFromSmsConfigFile, KGmsSmsConfigFileDir, KSimTsyConfigFileName);

	PRINTF1(_L("done"));

	if (createdDb)

		CleanupStack::PopAndDestroy(aPduDb);

	}

EXPORT_C CSmsMessage* CSmsStackTestUtils::CreateSmsMessageLC(CSmsPDU::TSmsPDUType aType, const TDesC& aDestination, const TDesC& aMessage)

	{

	CSmsBuffer* buffer = CSmsBuffer::NewL();

	buffer->InsertL(0, aMessage);

	CSmsMessage* message = CSmsMessage::NewL(iFs, aType, buffer);

	CleanupStack::PushL(message);

	message->SetToFromAddressL(aDestination);

	return message;

	}

EXPORT_C void CSmsStackTestUtils::AddSmsRxL(CTestConfig& aConfigFile, TInt aTestNumber, CSmsMessage& aMessage, const TDesC& aServiceCenter) const

	{

	_LIT8(KSmspTestUtilsSmsRx, "SmsRx");

	_LIT8(KSmspTestUtilsSmsRxFormat, "%S, %S");

	CTestConfigSection& section = GetSectionL(aConfigFile, aTestNumber);

	CArrayFixFlat<TGsmSms>* pdus = EncodeMessageLC(aMessage);

	const TInt pduCount = pdus->Count();

	for (TInt i = 0; i < pduCount; i++)

		{

		const TGsmSms& pdu = (*pdus)[i];

		HBufC8* pduBuf = ConvertToHexLC(pdu.Pdu());

		HBufC8* sc = HBufC8::NewLC(aServiceCenter.Length());

		sc->Des().Copy(aServiceCenter);

		const TInt maxLen = KSmspTestUtilsSmsRxFormat().Length() + pduBuf->Length() + sc->Length();

		HBufC8* smsRx = HBufC8::NewLC(maxLen);

		smsRx->Des().AppendFormat(KSmspTestUtilsSmsRxFormat, pduBuf, sc);

		CTestConfigItem* item = CTestConfigItem::NewLC(section, KSmspTestUtilsSmsRx, *smsRx);

		User::LeaveIfError(section.Items().Append(item));

		CleanupStack::Pop(item);

		CleanupStack::PopAndDestroy(smsRx);

		CleanupStack::PopAndDestroy(sc);

		CleanupStack::PopAndDestroy(pduBuf);

		}

	CleanupStack::PopAndDestroy(pdus);

	}

EXPORT_C CTestConfigSection& CSmsStackTestUtils::GetSectionL(CTestConfig& aConfigFile, TInt aTestNumber) const

	{

	_LIT8(KSmspTestUtilsTest, "test%d");

	TBuf8<16> test;

	test.AppendFormat(KSmspTestUtilsTest, aTestNumber);

	CTestConfigSection* section = aConfigFile.Section(test);

	if (section == NULL)

		{

		User::Leave(KErrNotFound);

		}

	return *section;

	}