// Copyright (c) 2009-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 "smsstackbaseteststeps.h"

#include <testconfigfileparser.h>

#include <simtsy.h>

#include <commsdattypesv1_1.h>

#include <gsmubuf.h>

#include <Gsmumsg.h>

#include <gsmuset.h>

#include <es_sock.h>

#include <smsustrm.h>

#include <c32root.h>

#include <sacls.h>

#include <e32math.h>

#include <smspver.h>

#include "smsstacktestutilities.h"

#include "smsstacktestconsts.h"

#include "smsstacktestcase.h"

#include "smspdudb.h"

using namespace CommsDat;

EXPORT_C CSmsBaseTestStep::CSmsBaseTestStep()

    {

    // empty

    }

EXPORT_C CSmsBaseTestStep::~CSmsBaseTestStep()

    {

    // empty       

    }

/**

    Creates the file server session and marks the heap

*/

EXPORT_C TVerdict CSmsBaseTestStep::doTestStepPreambleL()

    {

    RDebug::Print(_L("%S"), &TestStepName());

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

    __UHEAP_MARK;

    SetTestNumberFromConfigurationFileL();

    iSmsStackTestUtils = CSmsStackTestUtils::NewL(this,  iFs);

    iScheduler = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(iScheduler);

    TRAPD(ret, ParseSettingsFromFileL());

    TESTCHECK(ret, KErrNone, "ParseSettingsFromFileL");

    if (!iPartOfMultiStepTestCase)

        {

        ConnectSocketServerL(iSocketServer);

        }

    return TestStepResult();

    }

/**

    Closes file server session and unmarks the heap 

*/

EXPORT_C TVerdict CSmsBaseTestStep::doTestStepPostambleL()

    {

    if (!iPartOfMultiStepTestCase)

        {

        iSocketServer.Close();

        }

    delete iScheduler;

    iScheduler = NULL;

    delete iSmsStackTestUtils;

    iSmsStackTestUtils = NULL;

    __UHEAP_MARKEND;

    iFs.Close();

    if ( !iPartOfMultiStepTestCase && !iNotLastTestStep)

        {

        DoESockMemoryLeakTestL();

        }

    return TestStepResult();

    }

// TODO Method not needed - should be removed and replaced where appropriate

EXPORT_C void CSmsBaseTestStep::ParseSettingsFromFileL()

    {

    CTestConfig* configFile = CTestConfig::NewLC(iFs,KGmsSmsConfigFileDir,KGmsSmsConfigFileName);

    const CTestConfigSection* cfgFile = configFile->Section(KSetupTelNumbers);

    TESTCHECKCONDITIONL(cfgFile!=NULL, "Open SMS configuration file");

    const CTestConfigItem* item = cfgFile->Item(KServiceCenter,0);

    TESTCHECKCONDITIONL(item!=NULL, "Read ServiceCentre value from the configuration file");

    iServiceCenterNumber.Copy(item->Value());

    item = cfgFile->Item(KTelefoneNumber,0);

    TESTCHECKCONDITIONL(item!=NULL, "Read TelephoneNumber value from the configuration file");

    iTelephoneNumber.Copy(item->Value());

    CleanupStack::PopAndDestroy(configFile);

    }

/**

 * Read the test number from  the configuration file.

 * The test number is passed via property KUidPSSimTsyCategory. 

 * The SIM tsy uses test number to parse correct script from config.txt

 * @return ETrue, if the test number has been assigned successfully, otherwise EFalse.

 */

EXPORT_C void CSmsBaseTestStep::SetTestNumberFromConfigurationFileL()

    {

    TInt testNumber (0);

    if(GetIntFromConfig( ConfigSection(), KTestCaseNumber, testNumber))

        {

        SetSimTSYTestNumberL(testNumber);

        }

    }

EXPORT_C void CSmsBaseTestStep::SetSimTSYTestNumberL(TInt aTestNumber)

/**

    Set the SIM TSY Test number 

    @param aTestNumber is the test number in SIM TSY config file

*/

    {   

    SetTestNumberL(KPSSimTsyTestNumber, aTestNumber);

    }

/**

 *  The test number is set with property aTestNumberProperty. This will notify the SIM tsy.

 *  SIM tsy uses test number to parse correct script from the configuration file.

 *  @param aTestNumberProperty The test number property UID

 *  @param aTestNumber The test number corresponding the test case

 */

EXPORT_C void CSmsBaseTestStep::SetTestNumberL(TInt aTestNumberProperty, TInt aTestNumber)

    {

    //

    // Set the SIM.TSY test number...

    //

    RProperty testNumberProperty;

    User::LeaveIfError(testNumberProperty.Attach(KUidPSSimTsyCategory, aTestNumberProperty));

    CleanupClosePushL(testNumberProperty);

    TRequestStatus status;

    testNumberProperty.Subscribe(status);

    INFO_PRINTF3(_L("Setting SimTsy test number property (0x%X) to %d"), aTestNumberProperty, aTestNumber);

    User::LeaveIfError(testNumberProperty.Set(KUidPSSimTsyCategory, aTestNumberProperty, aTestNumber));

    User::WaitForRequest(status);

    TESTCHECK(status.Int(), KErrNone, "Setting SimTsy test number property ");

    TInt testNumberCheck;

    User::LeaveIfError(testNumberProperty.Get(testNumberCheck));

    TESTCHECK(aTestNumber, testNumberCheck, "Checking correct test number");

    CleanupStack::PopAndDestroy(&testNumberProperty);

    }

EXPORT_C void CSmsBaseTestStep::ConnectSocketServerL(RSocketServ& aSocketServer)

    {

    INFO_PRINTF1(_L("Connecting to the Socket Server..."));

    TInt  ret = aSocketServer.Connect(KSocketMessageSlots);

    if (ret != KErrNone)

        {

        ERR_PRINTF2(_L("Connecting to socket server failed [ret=%d]"), ret);

        }

    INFO_PRINTF1(_L("Clearing private data..."));

    _LIT(KWapReassemblyStoreName, "C:\\Private\\101F7989\\sms\\wapreast.dat");

    ret = iFs.Delete(KWapReassemblyStoreName);

    if( ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound )

        {

        ERR_PRINTF2(_L("Deleted WAP reassembly Store failed [ret=%d]"), ret);

        }

    _LIT(KReassemblyStoreName, "C:\\Private\\101F7989\\sms\\smsreast.dat");

    ret = iFs.Delete(KReassemblyStoreName);

    if( ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound )

        {

        ERR_PRINTF2(_L("Deleted reassembly Store failed [ret=%d]"), ret);

        }

    _LIT(KSegmentationStoreName, "C:\\Private\\101F7989\\sms\\smssegst.dat");

    ret = iFs.Delete(KSegmentationStoreName);

    if( ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound )

        {

        ERR_PRINTF2(_L("Deleted segmentation Store failed [ret=%d]"), ret);

        }

    _LIT(KSmsClass0PreallocatedStoreName, "C:\\Private\\101F7989\\sms\\smsclass0preallocated.dat");

    ret = iFs.Delete(KSmsClass0PreallocatedStoreName);

    if( ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound )

        {

        ERR_PRINTF2(_L("Deleted SmsClass0Preallocated Store failed [ret=%d]"), ret);

        }

    _LIT(KSmsClass0ReassemblyStoreName, "C:\\Private\\101F7989\\sms\\smsclass0reast.dat");

    ret = iFs.Delete(KSmsClass0ReassemblyStoreName);

    if( ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound )

        {

        ERR_PRINTF2(_L("Deleted SmsClass0Reassembly Store failed [ret=%d]"), ret);

        }

    _LIT(KSmsUtilityResourceFileName, "C:\\Private\\101F7989\\sms\\smsu.rsc");

    ret = iFs.Delete(KSmsUtilityResourceFileName);

    if( ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound )

        {

        ERR_PRINTF2(_L("Deleted SMS stack resource file failed [ret=%d]"), ret);

        }

    }

EXPORT_C void CSmsBaseTestStep::ConnectSocketServerLC(RSocketServ& aSocketServer)

    {

    ConnectSocketServerL(aSocketServer);

    CleanupClosePushL(aSocketServer);

    }

EXPORT_C CSmsMessage* CSmsBaseTestStep::CreateSmsMessageL(const TDesC& aDes, TSmsDataCodingScheme::TSmsAlphabet aAlphabet, CSmsPDU::TSmsPDUType aType)

/**

 *  Create a uninitialised SMS message

 *  @param aDes contains text that will be inserted to the pdu

 *  @param aAlphabet describes the alphabet of the pdu

 *  @return CSmsMessage* :Pointer to the created CSmsMessage object.

 */

    {

    CSmsMessage* smsMessage = CreateSmsMessageLC(aDes, aAlphabet, aType);

    CleanupStack::Pop(smsMessage);

    return smsMessage;

    }

EXPORT_C CSmsMessage* CSmsBaseTestStep::CreateSmsMessageLC(const TDesC& aDes, TSmsDataCodingScheme::TSmsAlphabet aAlphabet, CSmsPDU::TSmsPDUType aType)

/**

 *  Create a uninitialised SMS message

 *  @param aDes contains text that will be inserted to the pdu

 *  @param aAlphabet describes the alphabet of the pdu

 *  @return CSmsMessage* :Pointer to the created CSmsMessage object.

 */

    {

    CSmsBuffer* buffer=CSmsBuffer::NewL();

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

    CleanupStack::PushL(smsMessage);

    TSmsUserDataSettings smsSettings;

    smsSettings.SetAlphabet(aAlphabet);

    smsSettings.SetTextCompressed(EFalse);

    smsMessage->SetUserDataSettingsL(smsSettings);

    smsMessage->SetToFromAddressL(iTelephoneNumber);

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

    buffer->InsertL(0,aDes);

    return smsMessage;

    }

EXPORT_C CSmsMessage* CSmsBaseTestStep::CreateSmsWithStatusReportReqL(const TDesC& aDes, TSmsDataCodingScheme::TSmsAlphabet aAlphabet)

/**

 *  Create a uninitialised SMS message with Status Report request

 *  @param aDes contains text that will be inserted to the pdu

 *  @param aAlphabet describes the alphabet of the pdu

 *  @return CSmsMessage* :Pointer to the created CSmsMessage object.

 */

    {

    CSmsMessage* smsMessage=CreateSmsMessageLC(aDes, aAlphabet);

    //Set Status report request

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

    submitPdu.SetStatusReportRequest(ETrue);

    CleanupStack::Pop(smsMessage);

    return smsMessage;

    }

EXPORT_C CSmsMessage* CSmsBaseTestStep::RecvSmsL(RSocket& aSocket, TInt aIoctl)

/**

 *  Receive an Sms

 *  @param aSocket is used to stream the sms message from the socket server

 *  @return CSmsMessage* :Sms message from Sms stack

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

 */

    {

    CSmsBuffer* buffer=CSmsBuffer::NewL();

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

    CleanupStack::PushL(smsMessage);

    RSmsSocketReadStream readstream(aSocket);

    TRAPD(ret, readstream >> *smsMessage);

    TRequestStatus status;

    if(ret==KErrNone)

        {

        User::WaitForRequest(status);

        CleanupStack::Pop(smsMessage);

        TESTCHECK(status.Int(), KErrNone, "Notifying the SMS stack that message was received successfully");

        INFO_PRINTF1(_L("Message received successfully"));

        }

    //An error has occured, no message has been received

    else

        {

        User::WaitForRequest(status);

        TESTCHECK(status.Int(), KErrNone, "Notifying the SMS stack that message was not received");

        ERR_PRINTF2(_L("Receiving message failed %d"), ret);

        User::Leave(ret);

        }

    return smsMessage;  

    }

EXPORT_C CSmsMessage* CSmsBaseTestStep::RecvSmsFailedL(RSocket& aSocket)

/**

 *  Receive an Sms, first nack the receive several times before succeeding

 *  @param aSocket is used to stream the sms message from the socket server

 *  @return CSmsMessage* :Sms message from Sms stack

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

 *  @leave Leaves if nack of receiving is completed with error code

 *  @leave Leaves if ack of receiving is completed with error code

 */

    {

    CSmsBuffer* buffer=CSmsBuffer::NewL();

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

    CleanupStack::PushL(smsMessage);

    RSmsSocketReadStream readstream(aSocket);

    TPckgBuf<TUint> sbuf;

    TRequestStatus status;

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

        {

        TRAPD(ret,readstream >> *smsMessage);

        TEST(ret == KErrNone);

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

        User::WaitForRequest(status);

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

        }

    TRAPD(ret,readstream >> *smsMessage);

    TEST(ret == KErrNone);

    aSocket.Ioctl(KIoctlReadMessageSucceeded, status, NULL, KSolSmsProv);

    User::WaitForRequest(status);

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

    CleanupStack::Pop(smsMessage);

    return smsMessage;

    }

EXPORT_C void CSmsBaseTestStep::SendSmsL(const CSmsMessage* aSms, RSocket& aSocket, TInt aExpectedError/*=KErrNone*/, TInt aMaxRetries/*=3*/)

/**

 *  Stream aSms out to the socket server

 *  @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 aExpectedError The error expected from the send request

 *  @param aMaxRetries The max number of retries is send request does not match expected error

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

 *  @leave Leaves if sending is completed with error code

 */

    {

    INFO_PRINTF1(_L("Sending SMS... "));

    PrintMessageL(aSms);

    TBool tryAgain = ETrue;

    TInt sendTry (0);

    TRequestStatus status = KErrNone;

    while( tryAgain && sendTry < aMaxRetries )

        {

        RSmsSocketWriteStream writestream(aSocket);

        TRAPD(ret,writestream << *aSms);

        TRAP(ret, writestream.CommitL());

        TPckgBuf<TUint> sbuf;

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

        User::WaitForRequest(status);

        INFO_PRINTF3(_L("SendSmsL [status=%d, aExpectedError=%d]"), status.Int(), aExpectedError);

        if ( status.Int() != aExpectedError )

            {

            tryAgain = ETrue;

            INFO_PRINTF1(_L("Try again... "));

            ++sendTry;

            }

        else tryAgain = EFalse;

        }

    TESTCHECKL(status.Int(), aExpectedError, "Sending Message with an expected error");

    }

EXPORT_C void CSmsBaseTestStep::SendSmsCancelL(CSmsMessage* aSms, RSocket& aSocket1, RSocket& aSocket2)

/**

 *  Stream Sms out to the socket server by two RSmsSocketWriteStream object.

 *  The first request is canceled and then the second request is completed with error code.

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

 *  @param aSocket1 The socket used with message that will be canceled

 *  @param aSocket2 The socket used with message that will be completed with error code

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

 *  @leave Leaves if sending is completed with KErrNone

 */

    {

    RSmsSocketWriteStream writestream(aSocket1);

    TRAPD(ret,writestream << *aSms);

    TEST(ret == KErrNone);

    TRAP(ret,writestream.CommitL());

    TEST(ret == KErrNone);

    TPckgBuf<TUint> sbuf;

    TRequestStatus status1,status2;

    //stream to socket2

    RSmsSocketWriteStream writestream2(aSocket2);

    TRAP(ret,writestream2 << *aSms);

    TEST(ret == KErrNone);

    TRAP(ret,writestream2.CommitL());

    TEST(ret == KErrNone);

    aSocket1.Ioctl(KIoctlSendSmsMessage,status1,&sbuf, KSolSmsProv);

    aSocket2.Ioctl(KIoctlSendSmsMessage,status2,&sbuf, KSolSmsProv);

    User::After(2000000);

    // Test cancel first

    aSocket1.CancelIoctl();

    User::WaitForRequest(status1);

    TEST(status1.Int()==KErrCancel);

    User::After(50000);

    User::WaitForRequest(status2);

    INFO_PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"),status2.Int());

    PrintMessageL(aSms);

    //Ensure the request is completed with error code ;)

    TEST(status2.Int() != KErrNone);

    INFO_PRINTF2(_L("Sending failed! %d"), status2.Int());

    }

EXPORT_C TInt CSmsBaseTestStep::SendSmsErrorL(CSmsMessage* aSms, RSocket& aSocket)

/**

 *  Stream aSms out to the socket server. Sending is completed with error code.

 *  @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

 *  @return error code

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

 *  @leave Leaves if sending is completed with KErrNone

 */

    {

    RSmsSocketWriteStream writestream(aSocket);

    TRAPD(ret,writestream << *aSms);

    TEST(ret == KErrNone);

    TRAP(ret,writestream.CommitL());

    TEST(ret == KErrNone);

    TPckgBuf<TUint> sbuf;

    TRequestStatus status;

    User::After(50000);

    // test cancel first

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

    aSocket.CancelIoctl();

    User::WaitForRequest(status);

    TEST(status.Int()==KErrCancel);

    //Now send again, completed with error

    TRAP(ret,writestream << *aSms);

    TEST(ret == KErrNone);

    TRAP(ret,writestream.CommitL());

    TEST(ret == KErrNone);

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

    User::WaitForRequest(status);

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

    PrintMessageL(aSms);

    INFO_PRINTF2(_L("Sending failed! %d"), status.Int());

    TEST(status.Int() != KErrNone);

    return status.Int();

    }

EXPORT_C void CSmsBaseTestStep::SendCommandSmsL(CSmsMessage* aSms, RSocket& aSocket)

/**

 *  Stream command message out to the socket server and wait for the return status

 *  @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

 *  @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);

    TEST(ret == KErrNone);

    TRAP(ret,writestream.CommitL());

    TEST(ret == KErrNone);

    TRequestStatus status;

    TPckgBuf<TUint> sbuf;

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

    User::WaitForRequest(status);

    INFO_PRINTF2(_L("SendCommandSmsL, sendSms returned %d"), status.Int());

    User::After(1000000);

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

    }