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

//

#include "TE_smsstorbase.h"

#include "TE_smsstor.h"

TVerdict CSmsStorTestStep::doTestStepPreambleL()

	{

	__UHEAP_MARK;

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

	iTelephoneNumber =_L("+447747065825");     // Andre

	iServiceCenterNumber =_L("+447785016005"); // Vodafone

	iLogId = 1 ;

	iMsgRef = 1 ;

	iMsgBuf = NULL;

    return TestStepResult() ;

	}

TVerdict CSmsStorTestStep::doTestStepPostambleL()

	{

	iFs.Close();

	delete iMsgBuf;

	iMsgBuf = NULL;

	__UHEAP_MARKEND;

 	return TestStepResult() ;

	}

void CSmsStorTestStep::AddReferenceL( TInt aLogId, TInt aRef )

    {

    TSmsAddr iSmsAddr;

    iSmsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

    CSmsMessage* iSmsMessage;

    //@@@ later test for memory leak

    //CArrayFix<TInt>* iStatusArray=new(ELeave) CArrayFixFlat<TInt>(8);

    //CleanupStack::PushL(iStatusArray);

    iSmsMessage = CreateSmsMessageL(iMsgBuf->Des(),TSmsDataCodingScheme::ESmsAlphabet7Bit);

    CleanupStack::PushL(iSmsMessage);

    iSmsMessage->SetLogServerId( aLogId );

    CSmsSubmit& submitPdu=(CSmsSubmit&)iSmsMessage->SmsPDU();

    submitPdu.SetStatusReportRequest(ETrue);

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    iSegmentationStore->AddReferenceL( *iSmsMessage, aRef );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    CleanupStack::PopAndDestroy(); //iSmsMessage

    }

CSmsMessage* CSmsStorTestStep::CreateSmsMessageL(const TDesC& aDes,

							   TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

							   CSmsPDU::TSmsPDUType aPDUType)

//

// Create a uninitialised SMS message

//

    {

    CSmsBuffer* buffer=NULL;

    buffer=CSmsBuffer::NewL();

    CSmsMessage* smsMessage=NULL;

    smsMessage=CSmsMessage::NewL(iFs, aPDUType,buffer);

    CleanupStack::PushL(smsMessage);

    TSmsUserDataSettings smsSettings;

    smsSettings.SetAlphabet(aAlphabet);

    smsSettings.SetTextCompressed(EFalse);

    smsSettings.SetTextConcatenated(EFalse);

    switch( aPDUType )

        {

        case CSmsPDU::ESmsSubmit:

        case CSmsPDU::ESmsDeliver:

            {

            smsMessage->SetToFromAddressL(iTelephoneNumber);

            smsMessage->SmsPDU().SetServiceCenterAddressL(iServiceCenterNumber);

            if( aDes.Length() > 160 )

                smsSettings.SetTextConcatenated(ETrue);

            break;

            }

        case CSmsPDU::ESmsCommand:

            {

            smsMessage->SetToFromAddressL(iTelephoneNumber);

            smsMessage->SmsPDU().SetServiceCenterAddressL(iServiceCenterNumber);

            break;

            }

        case CSmsPDU::ESmsStatusReport:

            {

            smsMessage->SetToFromAddressL(iTelephoneNumber);

            smsMessage->SmsPDU().SetServiceCenterAddressL(iServiceCenterNumber);

            CSmsStatusReport& srPdu=(CSmsStatusReport&)smsMessage->SmsPDU();

            srPdu.SetParameterIndicatorPresent(ETrue);

            TEST(srPdu.ParameterIndicatorPresent());

            srPdu.SetProtocolIdentifierPresent(EFalse);

            TEST(!srPdu.ProtocolIdentifierPresent());

            srPdu.SetProtocolIdentifierPresent(ETrue);

            TEST(srPdu.ProtocolIdentifierPresent());

            break;

            }

        case CSmsPDU::ESmsSubmitReport:

        case CSmsPDU::ESmsDeliverReport:

            {

            break;

            }

        }

    if( aPDUType != CSmsPDU::ESmsCommand )

        {

        buffer->InsertL(0,aDes);

        smsMessage->SetUserDataSettingsL(smsSettings);

        }

	CArrayFixFlat<TGsmSms>* smsPdus = new (ELeave) CArrayFixFlat<TGsmSms>(8);

	CleanupStack::PushL(smsPdus);

	smsMessage->EncodeMessagePDUsL(*smsPdus);

	CleanupStack::PopAndDestroy(smsPdus);

    CleanupStack::Pop(smsMessage);

    return smsMessage;

    }

void CSmsStorTestStep::AddStatusReportL( TInt aLogId, TInt aRef, TSmsStatus::TSmsStatusValue aValue )

    {

    TSmsAddr iSmsAddr;

    iSmsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

    CSmsMessage* iOriginalSmsMessage = NULL;

    CSmsMessage* iSmsMessage;

	CSmsSegmentationStore::RSmsSegmentationStoreRefStatusArray refStatusArray;

	CleanupClosePushL(refStatusArray);

    TInt iIndex =0;

    TBool iIsComplete = EFalse;

    iSmsMessage = CreateSmsMessageL(_L("Status Report"),TSmsDataCodingScheme::ESmsAlphabet7Bit,CSmsPDU::ESmsStatusReport);

    CleanupStack::PushL(iSmsMessage);

    iSmsMessage->SetLogServerId( aLogId );

    CSmsStatusReport& statusPdu = (CSmsStatusReport&)iSmsMessage->SmsPDU();

    statusPdu.SetMessageReference(aRef);

    statusPdu.SetStatus(aValue);

    TBool found=iSegmentationStore->AddStatusReportL(iIndex,iIsComplete,*iSmsMessage);

    if (found)

        {

        CSmsBuffer*  buffer = CSmsBuffer::NewL();

        iOriginalSmsMessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsSubmit,buffer);

        iSegmentationStore->GetMessageL(iIndex,iSmsAddr,*iOriginalSmsMessage,refStatusArray);

        }

    if (iIsComplete)

        {

//      iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

        }

    if(iOriginalSmsMessage)

    	{

        delete iOriginalSmsMessage;

        }

    CleanupStack::PopAndDestroy(2); // iStatusArray, iSmsMessage

    }

void CSmsStorTestStep::SetGlobalsL(TSmsServiceCenterAddress aTel,

								   TSmsServiceCenterAddress aSC, TInt aMsgSize)

    {

    iTelephoneNumber =      aTel;

    iServiceCenterNumber  = aSC;

    delete iMsgBuf;

    iMsgBuf = HBufC::NewL(aMsgSize);

    TPtr msgPtr(iMsgBuf->Des());

    FillDes(msgPtr,aMsgSize);

    }

void CSmsStorTestStep::AddSubmitL( TInt aLogId )

    {

    TSmsAddr iSmsAddr;

    iSmsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

    CSmsMessage* iSmsMessage;

    //@@@ later test for memory leak

    //CArrayFix<TInt>* iStatusArray=new(ELeave) CArrayFixFlat<TInt>(8);

    //CleanupStack::PushL(iStatusArray);

    iSmsMessage = CreateSmsMessageL(iMsgBuf->Des(),TSmsDataCodingScheme::ESmsAlphabet7Bit);

    CleanupStack::PushL(iSmsMessage);

    iSmsMessage->SetLogServerId( aLogId );

    CSmsSubmit& submitPdu=(CSmsSubmit&)iSmsMessage->SmsPDU();

    submitPdu.SetStatusReportRequest(ETrue);

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    iSegmentationStore->AddSubmitL( iSmsAddr, *iSmsMessage );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    CleanupStack::PopAndDestroy(); //iSmsMessage

    }

void CSmsStorTestStep::TestSmsSegmentationStoreMessageTestL(TInt aMsgLen,

											TBool aDupMessageRef, TInt aAddCount)

/**

 *  Purges the segmentation store then...

 *  

 *  1. Adds a message to the segmentation store

 *  2. Adds a reference for each segment of the message

 *  3. Adds a temporary status report for each segment

 *  4. Adds a permanent status report for each segment

 *  

 */

	{

	INFO_PRINTF4(_L("SmsSegmentationStoreMessageTestL [aMsgLen=%d aDupMessageRef=%d aAddCount=%d]"), aMsgLen, aDupMessageRef, aAddCount);

	iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

	const TInt startCount = iSegmentationStore->Entries().Count();

    const TInt TmpLogId  = iLogId;

    const TInt TmpMsgRef = iMsgRef;

	TestAddStatusReportL(aMsgLen, iLogId, iMsgRef, TSmsStatus::ESmsTempError1StatusCongestion, aAddCount, ETrue, aDupMessageRef);

	iLogId = TmpLogId;

	iMsgRef = TmpMsgRef;

	TestAddStatusReportL(aMsgLen, iLogId, iMsgRef, TSmsStatus::ESmsShortMessageReceivedBySME, aAddCount, EFalse, aDupMessageRef);

	iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

	const TInt endCount = iSegmentationStore->Entries().Count();

	INFO_PRINTF3(_L("Complete [startCount=%d endCount=%d]"), startCount, endCount);

	TEST(endCount == startCount);

	}

void CSmsStorTestStep::TestAddStatusReportL(TInt aMsgLen, TInt& aStartLogId, TInt& aStartMsgRef, TSmsStatus::TSmsStatusValue aStatus, TInt aAddCount, TBool aAddSubmit, TBool aDupRef)

	{

	SetGlobalsL( _L("+447747065825"),_L("+44385016005"), aMsgLen);

	CSmsMessage* smsMessage = CreateSmsMessageL(iMsgBuf->Des(),TSmsDataCodingScheme::ESmsAlphabet7Bit);

	CleanupStack::PushL(smsMessage);

	const TInt numParts = smsMessage->NumMessagePDUsL();

	CleanupStack::PopAndDestroy(smsMessage);

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

        {

		if (aAddSubmit)

			AddSubmitL(aStartLogId);

		for (TInt j = 0; j < numParts; j++)

			{

			if (aAddSubmit)

				AddReferenceL(aStartLogId, aStartMsgRef);

			AddStatusReportL(aStartLogId, aStartMsgRef, aStatus);

			if (!aDupRef)

		        aStartMsgRef =  (aStartMsgRef + 1)  % 0x100;

			}

        aStartLogId++;

        aStartMsgRef =  (aStartMsgRef + 1)  % 0x100;

		//INFO_PRINTF1(_L("."));

        }

    delete iMsgBuf;

    iMsgBuf = NULL;

	}

void CSmsStorTestStep::TestSmsSegmentionStorePurge2L(TInt aMsgLen,

													 TInt aAddCount, TInt aDelivered)

	{

	INFO_PRINTF4(_L("TestSmsSegmentionStorePurge2L [aMsgLen=%d aAddCount=%d aDelivered=%d]"), aMsgLen, aAddCount, aDelivered);

	TEST(aDelivered <= aAddCount);

	TEST(aDelivered >= 0);

	TEST(aAddCount > 0);

	_LIT(KSegmentationStoreName,"C:\\System\\Data\\smssegst.dat");

	const TInt fileErr = iFs.Delete(KSegmentationStoreName);

	if (fileErr != KErrNotFound && fileErr != KErrPathNotFound)

		User::LeaveIfError(fileErr);

    iSegmentationStore=CSmsSegmentationStore::NewL(iFs);

    iSegmentationStore->OpenL(KSegmentationStoreName,KSegmentationStoreUid);

    TSmsAddr smsAddr;

    smsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

    CSmsBuffer* buffer = CSmsBuffer::NewL();

    CSmsMessage* smsMessage = CSmsMessage::NewL( iFs, CSmsPDU::ESmsSubmit, buffer );

    CleanupStack::PushL(smsMessage);

	CSmsSegmentationStore::RSmsSegmentationStoreRefStatusArray refStatusArray;

	CleanupClosePushL(refStatusArray);

    const TInt TmpLogId  = iLogId;

    const TInt TmpMsgRef = iMsgRef;

	TInt msgCount = aAddCount;

	TestAddStatusReportL(aMsgLen, iLogId, iMsgRef, TSmsStatus::ESmsTempError1StatusCongestion, aAddCount, ETrue, EFalse);

	//Purge the segmentation store

    iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

	// Check that all messages still exist in the iSegmentationStore

    for(TInt i = 0; i < iSegmentationStore->Entries().Count(); i++ )

        {

		iSegmentationStore->GetMessageL( i, smsAddr, *smsMessage, refStatusArray );

		msgCount--;

        }

	TEST(msgCount == 0);

	iLogId = TmpLogId;

	iMsgRef = TmpMsgRef;

	TestAddStatusReportL(aMsgLen, iLogId, iMsgRef, TSmsStatus::ESmsShortMessageReceivedBySME, aDelivered, EFalse, EFalse);

    iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

	// Check that all messages were removed from the iSegmentationStore

	TInt afterCount = iSegmentationStore->Entries().Count();

	TEST(afterCount== (aAddCount-aDelivered));

	if (aAddCount != aDelivered)

		{

		TestAddStatusReportL(aMsgLen, iLogId, iMsgRef, TSmsStatus::ESmsShortMessageReceivedBySME, aAddCount-aDelivered, EFalse, EFalse);

	    iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

		afterCount = iSegmentationStore->Entries().Count();

		TEST(afterCount==0);

		}

	CleanupStack::PopAndDestroy(&refStatusArray);

	CleanupStack::PopAndDestroy(smsMessage);

	delete iSegmentationStore ;

	iSegmentationStore = NULL;

	INFO_PRINTF1(_L("Complete"));

	}

void CSmsStorTestStep::CreateNewSegmentationStoreL()

    {

    //Create the segmentation store for the first time adding messages.

    _LIT(KCreateNewSegmentationStore, "Create segmentation store");

    INFO_PRINTF1(KCreateNewSegmentationStore);

    _LIT(KSegmentationStoreName,"C:\\System\\Data\\smssegst.dat");

    const TInt fileErr = iFs.Delete(KSegmentationStoreName);

    if (fileErr != KErrNotFound && fileErr != KErrPathNotFound)

         {

         User::LeaveIfError(fileErr);

         }

    iSegmentationStore=CSmsSegmentationStore::NewL(iFs);  

    iSegmentationStore->OpenL(KSegmentationStoreName,KSegmentationStoreUid);

    }

void CSmsStorTestStep::DeleteSegmetationStore()

    {

    _LIT(KDeleteSegmetationStore, "Delete segmentation store");

    INFO_PRINTF1(KDeleteSegmetationStore);

    delete iSegmentationStore ;

    iSegmentationStore = NULL;

    }

TInt CSmsStorTestStep::ReadMaxNumMessageValueL()

    {

    _LIT(KReadMaxNumMessageValue, "Read maximum number of messages");

    INFO_PRINTF1(KReadMaxNumMessageValue);

    _LIT(KSmseskfile, "smswap.sms.esk");

    CESockIniData* ini = CESockIniData::NewL(KSmseskfile);

    CleanupStack::PushL(ini);

    TInt ret = 0;

    TPtrC value;

    if(ini->FindVar(_L("SegmentationStoreOptions"),_L("MaxNumOfMessInSegStore"),value))

        {

        TLex16 valueconv(value);

        valueconv.Val(ret); 

        CleanupStack::PopAndDestroy(ini);

        INFO_PRINTF2(_L("MaxNumOfMessInSegStor = %d"), ret);

        }

    else

        {

        _LIT(KErrorMessage, "[SegmentationStoreOptions] is not defined in .esk file");

        ERR_PRINTF1(KErrorMessage);

        User::Leave(KErrNotFound);

        }

    return ret;

    }

void CSmsStorTestStep::AddMessageAndCheckPurgeL(TInt aAddNumMessages, TInt aExpectedNumMessages)

    {

    TestAddStatusReportL(20, iLogId, iMsgRef, TSmsStatus::ESmsTempError1StatusCongestion, aAddNumMessages, ETrue, EFalse);

    //Purge the segmentation store

    iSegmentationStore->PurgeL(iSmsSettings.KSegmentationLifetimeMultiplier(),EFalse);

    if(aExpectedNumMessages != iSegmentationStore->Entries().Count())

        {

        ERR_PRINTF3(_L("Number of messages in segmentation store = %d does not match expected %d"), iSegmentationStore->Entries().Count(), aExpectedNumMessages);

        SetTestStepResult(EFail);

        }

    }

void CSmsStorTestStep::CheckSegmentationStoreForMessagesL(RArray<TInt>& aLogIdsToFind)

    {

//Get Messages in segmentation Store and check their log ids to make sure aLogIdsToFind are included

    _LIT(KCheckSegmentationStoreForMessages, "Check segmentation store for given messages");

    INFO_PRINTF1(KCheckSegmentationStoreForMessages);

    CSmsBuffer* buffer = CSmsBuffer::NewL();

    CSmsMessage* smsMessage = CSmsMessage::NewL( iFs, CSmsPDU::ESmsSubmit, buffer );

    CleanupStack::PushL(smsMessage);

    CSmsSegmentationStore::RSmsSegmentationStoreRefStatusArray refStatusArray;

    CleanupClosePushL(refStatusArray);

    TInt msgCountFound = 0;

    const TInt countLogIdsToFind = aLogIdsToFind.Count();

    const TInt countLogIds = iSegmentationStore->Entries().Count();

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

        {

        TSmsAddr smsAddr;

        smsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

        iSegmentationStore->GetMessageL( i, smsAddr, *smsMessage, refStatusArray );

        TInt id = smsMessage->LogServerId();

        for(TInt jj = 0; jj < countLogIdsToFind; ++jj)

            {

            if(id == aLogIdsToFind[jj])

                {

                ++msgCountFound;

                break;

                }

            }

        }

    INFO_PRINTF3(_L("Expecting %d message in store - found %d"), msgCountFound, countLogIdsToFind);

    TEST(msgCountFound == countLogIdsToFind);

    CleanupStack::PopAndDestroy(&refStatusArray);

    CleanupStack::PopAndDestroy(smsMessage);

    }

void CSmsStorTestStep::AddDeliverL( TInt aIndex )

    {

    // adding a message to the reassemblystore

  //  TInt iIndex=0;

    CArrayFix<TGsmSms>* smsArray= new(ELeave) CArrayFixFlat<TGsmSms>(10);

    CleanupStack::PushL(smsArray);

    CSmsMessage* smsMsg = CreateSmsMessageL(iMsgBuf->Des(),TSmsDataCodingScheme::ESmsAlphabet7Bit,CSmsPDU::ESmsDeliver);

    CleanupStack::PushL(smsMsg);

    //iSmsMessage->SetLogServerId( aLogId );

    CSmsDeliver& deliverPdu = (CSmsDeliver&)smsMsg->SmsPDU();

    deliverPdu.SetMoreMessagesToSend(EFalse);

    smsMsg->EncodeMessagePDUsL(*smsArray);

    TRAP_IGNORE(iReassemblyStore->NewMessagePDUL(aIndex,*smsMsg,smsArray->At(0)));

    TSAREntry entry=iReassemblyStore->Entries()[aIndex];

    smsMsg->SetLogServerId(entry.LogServerId());

    smsMsg->SetTime(entry.Time());

    CleanupStack::PopAndDestroy(2); // smsMsg, smsArray

	}

void CSmsStorTestStep::DoEncodePDUsL(TInt aSize, TSmsDataCodingScheme::TSmsAlphabet aAlphabet, CSmsPDU::TSmsPDUType aPDUType)

    {

    TSmsAddr iSmsAddr;

    iSmsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

    CSmsMessage* iSmsMessage;

    CArrayFix<TGsmSms>* smsArray= new(ELeave) CArrayFixFlat<TGsmSms>(10);

    TGsmSms gsmSms = TGsmSms();

    TBool mobileTerminated = EFalse;

    if(    (aPDUType == CSmsPDU::ESmsDeliver)

       ||  (aPDUType == CSmsPDU::ESmsSubmitReport)

       ||  (aPDUType == CSmsPDU::ESmsStatusReport))

        mobileTerminated = ETrue;

    HBufC* MsgBuf = HBufC::NewLC(aSize);

    TPtr msgPtr   = MsgBuf->Des();

    FillDes(msgPtr,aSize);

    iSmsMessage = CreateSmsMessageL(msgPtr,aAlphabet,aPDUType);

    CleanupStack::PushL(iSmsMessage);

    // if concatenated message

    if( aSize > 160 )

        {

        TSmsUserDataSettings smsSettings;

        iSmsMessage->UserDataSettings(smsSettings);

        smsSettings.SetTextConcatenated(ETrue);

        iSmsMessage->SetUserDataSettingsL(smsSettings);

        }

    CSmsPDU& pdu = (CSmsPDU&)iSmsMessage->SmsPDU();

    if( aPDUType != CSmsPDU::ESmsCommand )

        {

        TSmsDataCodingScheme::TSmsClass smsclass, gsmsclass;

        smsclass = TSmsDataCodingScheme::ESmsClass0;

        pdu.SetClass(ETrue, smsclass );

        TEST(pdu.Class(gsmsclass));

        TEST( gsmsclass == smsclass );

        }

//

//  Check before Encoding and Decoding of the CSmsMessage

//

    //

    //  Check the Deliver PDU

    //

    if( aPDUType == CSmsPDU::ESmsDeliver )

        {

        CSmsDeliver& delPdu=(CSmsDeliver&)iSmsMessage->SmsPDU();

        delPdu.SetMoreMessagesToSend(EFalse);

        TEST( delPdu.MoreMessagesToSend() == EFalse);

        delPdu.SetMoreMessagesToSend(ETrue);

        TEST( delPdu.MoreMessagesToSend());