// Copyright (c) 2004-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 <bautils.h>

#include "gsmuieoperations.h"

#include "gsmunonieoperations.h"

TVerdict CSmsSegmentionStorePurge::doTestStepL()

	{

	_LIT(KSegmentationStoreFileName,"C:\\Private\\101FE442\\smssegst.dat");

	TInt  fileErr = iFs.Delete(KSegmentationStoreFileName);

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

		{

		User::LeaveIfError(fileErr);

		}

    iSegmentationStore=CSmsSegmentationStore::NewL(iFs);

	INFO_PRINTF2(_L("Seg Store 0x%X"), iSegmentationStore);

	INFO_PRINTF1(_L("Calling OpenL"));

    iSegmentationStore->OpenL(KSegmentationStoreName,KSegmentationStoreUid);

    INFO_PRINTF1(_L("OpenL Successful"));

    // TODO iSmsSettings.KSegmentationLifetimeMultiplier() = 1000 ??

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

	INFO_PRINTF1(_L("PurgeL"));

    TSmsAddr smsAddr;

    smsAddr.SetSmsAddrFamily(ESmsAddrRecvAny);

    CSmsMessage* originalSmsMessage = NULL;

    CSmsMessage* smsMessage;

	CSmsSegmentationStore::RSmsSegmentationStoreRefStatusArray refStatusArray;

	CleanupClosePushL(refStatusArray);

	CSmsSegmentationStore::RSmsSegmentationStoreRefStatusArray refStatusArray2;

	CleanupClosePushL(refStatusArray2);

    smsMessage = CreateSmsMessageL(_L("Test message"),TSmsDataCodingScheme::ESmsAlphabet7Bit);

    CleanupStack::PushL(smsMessage);

    INFO_PRINTF1(_L("CreateSmsMessageL"));

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

    submitPdu.SetStatusReportRequest(ETrue);

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

    iSegmentationStore->AddSubmitL( smsAddr, *smsMessage );

    INFO_PRINTF1(_L("AddSubmitL"));

    iSegmentationStore->AddReferenceL( *smsMessage, 5 );

    INFO_PRINTF1(_L("AddReferenceL"));

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

    CleanupStack::PopAndDestroy(); //smsMessage

    TInt index =0;

    TBool isComplete = EFalse;

    smsMessage = CreateSmsMessageL(_L("Test mesage"),TSmsDataCodingScheme::ESmsAlphabet7Bit,CSmsPDU::ESmsStatusReport);

    CleanupStack::PushL(smsMessage);

    INFO_PRINTF1(_L("CreateSmsMessageL"));

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

    statusPdu.SetMessageReference(5);

    const TInt reference=statusPdu.MessageReference();

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

    TBool found=iSegmentationStore->AddStatusReportL(index,isComplete,*smsMessage);

    INFO_PRINTF1(_L("AddStatusReportL"));

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

    if (found)

        {

        const TSmsSegmentationEntry& entry =

            ( const TSmsSegmentationEntry& )iSegmentationStore->Entries()[index];

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

        CSmsBuffer* buffer = CSmsBuffer::NewL();

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

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

        iSegmentationStore->GetMessageL( index, smsAddr, *originalSmsMessage, refStatusArray );

        INFO_PRINTF1(_L("GetMessageL"));

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

         }

    if (isComplete)

        {

        smsMessage->SetTime(originalSmsMessage->Time());

        smsMessage->SetToFromAddressL(originalSmsMessage->ToFromAddress());

        TInt count=refStatusArray.Count();

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

		TInt refStatusPos = refStatusArray.Find(reference); 

		TEST(refStatusPos != KErrNotFound);

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

            {

            const TInt status=refStatusArray[i].Status();

            statusreport.SetStatus((TSmsStatus::TSmsStatusValue) status);

            if (status!=TSmsStatus::ESmsShortMessageReceivedBySME)

                break;

            }

        }

	refStatusArray2.CopyL(refStatusArray);

	refStatusArray2.ResetAllStatus();

	const TInt count2 = refStatusArray.Count();

	__ASSERT_DEBUG(count2 == refStatusArray2.Count(),SmspPanic(KSmspPanicBadReferenceArray));

    //    iSegmentationStore->AddReferenceL( *ismsMessage, 6 );

    //    iSegmentationStore->AddReferenceL( *ismsMessage, 7 );

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

    if(originalSmsMessage)

        delete originalSmsMessage;

    CleanupStack::PopAndDestroy(3); // iStatusArray, smsMessage

    delete iSegmentationStore;

    iSegmentationStore = NULL;

	return TestStepResult();

	}

TVerdict CSmsSegmentionStorePurge1::doTestStepL()

	// Background information

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

	//

	// Each TSAREntry contains the following attributes

	//	iReference - concatenation reference number

	//	iTotal - total number of PDUs

	//	iCount - the number of PDUs sent

	//	iData1 - Bytes 0 & 1 Number of PDUs that have been negatively

	//               acknowledged with a permanent failure notification.

	//		 Bytes 2 & 3 - Number of PDUs that have been acknowledged

	//		 as successfully received by the far end.

	//

	// The segmentation store maintains a collection of reference/status pairs

	// for each message message in the store. TSAREntry::iCount is set to the

	// size of this collection.

	//

	// The test follows the following routine:

	//  1) it creates an entry in the CSmsSegmentationStore for each submit message.

	//  2) it adds a reference for each part of the message.

	//  3) it attempts to update the store with a temporary status value for each message value

	//     (although the store internally discards the temporary values).

	//  4) it updates the store with a permanent status value for each message reference.

	//

	// The test finishes by purging the store. The test expects that every message should

	// be purged. This is because every message in the store should satisfy the condition (1)

	// in the following method:

	//

	// void CSARStore::PurgeL

	//		(entry.IsComplete() && (deliv_n_failed >= entry.Total())) // condition 1

	//		||

	//		((time>(entry.Time()+lifetime)) && !aPurgeIncompleteOnly ) // condition 2

	//		{

	//		  DoDeleteEntryL(i);

	//		}

	// Condition 2 is used to purge incomplete messages whose time stamp exceeds their

	// validity period - this condition should never be exercised in this test.

	//

	// The following test cases are used:

	//	TestSmsSegmentationStoreMessageTestL(20);            // Test 1

	//

	//	TestSmsSegmentationStoreMessageTestL(200, EFalse);   // Test 2

	//	TestSmsSegmentationStoreMessageTestL(200, ETrue);    // Test 3

	//	TestSmsSegmentationStoreMessageTestL(500, EFalse);   // Test 4

	//	TestSmsSegmentationStoreMessageTestL(500, ETrue);    // Test 5

	//

	// Test 1 simulates sending 20 messages, each encoded into a single PDU containing 20 characters.

	// Test 2 simulates sending 20 messages, each encoding a 200 character mesage into multiple PDUs using

	//  a unique message reference for each PDU.

	// Test 3 - as per test 2 but although the message reference is incremented after every message, the same

	//  (i.e. a duplicate) message reference is used for each of the message's PDUs. This simulates the

	//  message reference number (range 0..255) wrapping around when sending long messages.

	// Tests 4 & 5 are as per 2/3 but with 500 characters.

	{

	_LIT(KSegmentationStoreFileName,"C:\\Private\\101FE442\\smssegst.dat");

	TInt  fileErr = iFs.Delete(KSegmentationStoreFileName);

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

		{

		User::LeaveIfError(fileErr);

		}

    iSegmentationStore=CSmsSegmentationStore::NewL(iFs);

    iSegmentationStore->OpenL(KSegmentationStoreName,KSegmentationStoreUid);

    // TODO iSmsSettings.KSegmentationLifetimeMultiplier() = 1000 ??

	TestSmsSegmentationStoreMessageTestL(20);

	TestSmsSegmentationStoreMessageTestL(200, EFalse);

	TestSmsSegmentationStoreMessageTestL(200, ETrue);

	TestSmsSegmentationStoreMessageTestL(500, EFalse);

	TestSmsSegmentationStoreMessageTestL(500, ETrue);

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

    delete iSegmentationStore;

    iSegmentationStore = NULL;

    return TestStepResult();

    }

TVerdict CSmsSegmentionStorePurge2::doTestStepL()

    {

	TestSmsSegmentionStorePurge2L(20, 20, 20);

	TestSmsSegmentionStorePurge2L(200, 20, 20);

	TestSmsSegmentionStorePurge2L(200, 20, 5);

	TestSmsSegmentionStorePurge2L(200, 20, 0);

	return TestStepResult();

    }

TVerdict CSmsSegmentionStorePurge3::doTestStepL()

    {

    INFO_PRINTF1(_L("Testing segmentation store max number of messages"));

    //Read maximum number of messages from c:\private\101fe442\smswap.sms.esk (the value of the section [SegmentationStoreOptions])  

    TInt maxNumMessages = ReadMaxNumMessageValueL();

//Test 1 Make sure there are maximum messages in the segmentation store after adding 25 incomplete messages which exceeds the limit allowed in segmentation store. 

    CreateNewSegmentationStoreL();

    // Add 5 more incomplete messages more than the limit.

    TInt numMessage = maxNumMessages + 5;

    AddMessageAndCheckPurgeL(numMessage, maxNumMessages); 

//Test 2 Make sure there are still maximun messages in the segmentation store after adding more incompleted messages which exceeds the limit allowed in segmentation store.

    TInt startLogId = iLogId;

    //Add another maximum number of incomplete messages

    AddMessageAndCheckPurgeL(maxNumMessages, maxNumMessages);

    //Make sure that the newly added messages are not deleted from the store (first in first out)

    //Get log ids for those newly added messages

    RArray<TInt> logIds;

    CleanupClosePushL(logIds);

    for(TInt ii = 0; ii < maxNumMessages; ++ii)

        {

        logIds.AppendL(startLogId++);

        }

    //Test that those two messages are not deleted from the store

    CheckSegmentationStoreForMessagesL(logIds);

    CleanupStack::PopAndDestroy(&logIds);

    DeleteSegmetationStore();

    INFO_PRINTF1(_L("Complete"));  

    return TestStepResult();

    }

TVerdict CSmsSegmentionStorePurge4::doTestStepL()

    {

#if defined (__WINS__)

    INFO_PRINTF1(_L("Test that the maximum number of messages in segmentaion store is set to 0"));

    //Read maximum number of messages from c:\private\101fe442\smswap.sms.esk. The value should be set to 0

    TInt maxNumMessages = ReadMaxNumMessageValueL();

    TEST(maxNumMessages == 0);

    CreateNewSegmentationStoreL();

    //Make sure there are as many as messages can be stored in the segmentation store. 

    const TInt numMessage = 1000;// It could be any number

    AddMessageAndCheckPurgeL(numMessage, numMessage);

    //Make sure it is possible to add more messages.

    const TInt numMoreMessage = 5;

    AddMessageAndCheckPurgeL(numMoreMessage, numMessage + numMoreMessage);

    DeleteSegmetationStore();

    INFO_PRINTF1(_L("Complete"));

#else

	INFO_PRINTF1(_L("CSmsSegmentionStorePurge4::doTestStepL() is not running in hardware because it takes too long to finish"));

#endif

	return TestStepResult();

    }

TVerdict CReassemblystore3::doTestStepL()

	{

	_LIT(KReassemblyStoreFileName, "C:\\Private\\101FE442\\smsreast.dat");

	TInt  fileErr = iFs.Delete(KReassemblyStoreFileName);

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

		{

		User::LeaveIfError(fileErr);

		}

	// initialisation of the reassembly store

    iReassemblyStore=CSmsReassemblyStore::NewL(iFs);

    iReassemblyStore->OpenL(KReassemblyStoreName,KReassemblyStoreUid);

    iReassemblyStore->PurgeL(iSmsSettings.ReassemblyLifetime(), ETrue);

	iReassemblyStore->BeginTransactionLC();

    iReassemblyStore->CompactL();

	iReassemblyStore->CommitTransactionL();

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

    // adding a message to the reassemblystore

    TInt index=0;

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

    CleanupStack::PushL(smsArray);

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

    CleanupStack::PushL(smsMsg);

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

    deliverPdu.SetMoreMessagesToSend(EFalse);

    smsMsg->EncodeMessagePDUsL(*smsArray);

    TRAPD(ret,iReassemblyStore->NewMessagePDUL(index,*smsMsg,smsArray->At(0)));

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

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

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

    index = 1;

    ret = KErrNone;

	iReassemblyStore->BeginTransactionLC();

	TEST(iReassemblyStore->FindMessageL(*smsMsg, EFalse, index));

	if(iReassemblyStore->FindMessageL(*smsMsg, EFalse, index))

	        TRAP(ret,iReassemblyStore->DeleteEntryL(index));

	TEST(ret == KErrNone);

	iReassemblyStore->CommitTransactionL();

    iReassemblyStore->PurgeL(iSmsSettings.ReassemblyLifetime(), ETrue);

	iReassemblyStore->BeginTransactionLC();

    iReassemblyStore->CompactL();

	iReassemblyStore->CommitTransactionL();

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

    delete iReassemblyStore;

    iReassemblyStore = NULL;

    return TestStepResult();

    }

TVerdict CReassemblystore2::doTestStepL()

	{

	//

    //  TODO - ahe - to test purging of the reastore

    //  or to give this test case a sense

    //

    // initialisation of the reassembly store

    iReassemblyStore=CSmsReassemblyStore::NewL(iFs);

    iReassemblyStore->OpenL(KReassemblyStoreName,KReassemblyStoreUid);

    iReassemblyStore->PurgeL(iSmsSettings.ReassemblyLifetime(), ETrue);

	//TODO Maybe this is not needed anymore (iReassemblyStore->CommitTransactionL())

	//    iReassemblyStore->CompactL();

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

    CSmsBuffer* buffer=CSmsBuffer::NewL();

    CSmsMessage* smsmessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsDeliver,buffer);

    CleanupStack::PushL(smsmessage);

    TInt i;

	TInt msgCount=20;

    for( i = 0; i < msgCount ; i++ )

        {

        AddDeliverL(i);

	    iReassemblyStore->BeginTransactionLC();

		iReassemblyStore->SetPassedToClientL(i, EFalse );

	    iReassemblyStore->CommitTransactionL();

        }

	// Check that all messages still exist in the iReassemblyStore

    iReassemblyStore->BeginTransactionLC();

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

        {

        TRAPD(ret,iReassemblyStore->GetMessageL(i,*smsmessage));

        TEST(ret==KErrNone);

		msgCount--;

        }

    iReassemblyStore->CommitTransactionL();

	//msgCount must be 0!!

	//GLOBAL_CHECKPOINT_CODE(msgCount); //vep, will leave because of possible defect in gsmu

	// Messages will be passed now to client

    for( i = 0; i < 20 ; i++ )

        {

	    iReassemblyStore->BeginTransactionLC();

		iReassemblyStore->SetPassedToClientL(i, ETrue );

	    iReassemblyStore->CommitTransactionL();

        }

    CleanupStack::PopAndDestroy(smsmessage);

	// Same again with concatenated pdus

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

    buffer=CSmsBuffer::NewL();

    smsmessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsDeliver,buffer);

    CleanupStack::PushL(smsmessage);

	msgCount=20;

    for( i = 0; i < msgCount ; i++ )

        {

        AddDeliverL(i);

	    iReassemblyStore->BeginTransactionLC();

		iReassemblyStore->SetPassedToClientL(i, EFalse );

	    iReassemblyStore->CommitTransactionL();

        }

	// Check that all messages still exist in the iReassemblyStore

    iReassemblyStore->BeginTransactionLC();

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

        {

        TRAPD(ret,iReassemblyStore->GetMessageL(i,*smsmessage));

        TEST(ret == KErrNone);

        }

    iReassemblyStore->CommitTransactionL();

	// Messages will be passed now to client

    for( i = 0; i < 20 ; i++ )

        {

	    iReassemblyStore->BeginTransactionLC();

		iReassemblyStore->SetPassedToClientL(i, ETrue);

	    iReassemblyStore->CommitTransactionL();

        }

    CleanupStack::PopAndDestroy(smsmessage);

	// Same again with mixture of entries

	// 5 messages are passed to client

	// 15 messages aren't passed

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

    buffer=CSmsBuffer::NewL();

    smsmessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsDeliver,buffer);

    CleanupStack::PushL(smsmessage);

	msgCount=20;

	TInt notPassed = 15;

    for( i = 0; i < msgCount ; i++ )

        {

        AddDeliverL(i);

	    iReassemblyStore->BeginTransactionLC();

		if (i<notPassed)

			iReassemblyStore->SetPassedToClientL(i, EFalse );

		else

			iReassemblyStore->SetPassedToClientL(i, ETrue );

	    iReassemblyStore->CommitTransactionL();

        }

	// Check that 15 (not passed) messages still exist in the iReassemblyStore

	msgCount = iReassemblyStore->Entries().Count();

	// Rest of messages will be passed now to client

    for( i = 0; i < notPassed ; i++ )

        {

	    iReassemblyStore->BeginTransactionLC();

		iReassemblyStore->SetPassedToClientL(i, ETrue );

	    iReassemblyStore->CommitTransactionL();

        }

    CleanupStack::PopAndDestroy(smsmessage);

    iReassemblyStore->PurgeL(iSmsSettings.ReassemblyLifetime(), ETrue);

	// Check that all messages were removed from the iSegmentationStore

	//TInt afterCount = iReassemblyStore->Entries().Count();

	//GLOBAL_CHECKPOINT_CODE(afterCount);

    delete iReassemblyStore; //allocated in SetGlobals

    iReassemblyStore = NULL;

    return TestStepResult();

	}

TVerdict CEncodePDUs::doTestStepL()

	{

/*  enum TSmsPDUType

        {

        };*/

/*

    const TUint KSocketMessageSlots = 16;

    RSocketServ ss;

    TInt ret=ss.Connect(KSocketMessageSlots);

    GLOBAL_CHECKPOINT_CODE(ret);

    RSocket socket;

    //OpenSmsSocketL(socket,ESmsAddrLocalOperation);

    ret=socket.Open(ss,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);

    GLOBAL_CHECKPOINT_CODE(ret);

    TSmsAddr smsaddr;

    smsaddr.SetSmsAddrFamily(ESmsAddrLocalOperation);

    //smsaddr.SetSmsAddrFamily(aFamily);

    ret=socket.Bind(smsaddr);

    GLOBAL_CHECKPOINT_CODE(ret);

    CleanupClosePushL(socket);

*/

    DoEncodePDUsL( 20, TSmsDataCodingScheme::ESmsAlphabet7Bit,CSmsPDU::ESmsDeliver );

    DoEncodePDUsL( 20, TSmsDataCodingScheme::ESmsAlphabet8Bit,CSmsPDU::ESmsDeliver );