/*

* Copyright (c) 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: This file contains testclass implementation.

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <msgqlib.h>

#include <msg_enums.h>

#include <msgliterals.h>

#include <stdlib.h>

#include <msgqinternal.h>

#include "messagequeue_api.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

// function_name    : running isolation server exe

// description      : Deallocates all the data

// Returns          : None

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

  int  run_isoserver()

  {

    // running isoserver 

    RProcess isosrv_launcher;

    TInt lunch_err = 0;

    _LIT(KProcess, "isoserver.exe");

    lunch_err = isosrv_launcher.Create( KProcess, KNullDesC );

     if ( KErrNone != lunch_err ) 

        {

        return KErrGeneral;

        }

    isosrv_launcher.Resume();

    return KErrNone;

  }

// ============================ MEMBER FUNCTIONS ===============================

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

// Cmessagequeue_api::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void Cmessagequeue_api::Delete() 

    {

    }

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

// Cmessagequeue_api::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt Cmessagequeue_api::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

        ENTRY( "TestMessageQCreate", Cmessagequeue_api::TestMessageQCreate ),

        ENTRY( "TestMessageQSend", Cmessagequeue_api::TestMessageQSend ),

        ENTRY( "TestMessageQDelete", Cmessagequeue_api::TestMessageQDelete ),

        ENTRY( "TestMessageQReceive", Cmessagequeue_api::TestMessageQReceive ),

        ENTRY( "TestMessageQClean", Cmessagequeue_api::TestMessageQClean ),

        ENTRY( "TestMessageQCheck", Cmessagequeue_api::TestMessageQCheck ),

        ENTRY( "TestMsgQMaxCheck", Cmessagequeue_api::TestMsgQMaxCheck ),

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// Cmessagequeue_api::ExampleL

// Example test method function.

// (other items were commented in a header).

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

//

TInt Cmessagequeue_api::TestMessageQCreate( CStifItemParser& aItem )

    {

        char smsg[MAX_MSG_SIZE];

        char rmsg[MAX_MSG_SIZE];

        int index=0;

        int timeout = 100;

        int nBytes;

        int result = 0;

        int err = 0;

        int status = 0;

        int run_iso;

        FILE *fp;

        message_hdr_req *msgHdr = NULL;  

        message_hdr_resp* msg_struct = NULL;

        TInt return_value = 0;

        memset( smsg, '\0', MAX_MSG_SIZE );

        memset( rmsg, '\0', MAX_MSG_SIZE );

        //running isoserver   

        run_iso = run_isoserver(); 

        if(run_iso)

           {

           iLog->Log ( _L ( "running isolation server is failed" ) );

           return KErrGeneral;

            }             

         //create message queue for send request

        result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

           iLog->Log ( _L ( "creating requet queue is failed" ) );

           return KErrGeneral;

            }

       //create message queue for response request

        result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

            iLog->Log ( _L ( "creating requet queue is failed" ) );

            return KErrGeneral;

            }

            index=0;

            memset( smsg, '\0', MAX_MSG_SIZE );

            memset( rmsg, '\0', MAX_MSG_SIZE );

            msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

            memset( msgHdr, '\0', sizeof( message_hdr_req ) );

            msgHdr->message_type = EKill_Process;

            memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

            index += sizeof( message_hdr_req );

            result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

            free(msgHdr);           

           return KErrNone;

    }

TInt Cmessagequeue_api::TestMessageQSend( CStifItemParser& aItem )

    {

        char smsg[MAX_MSG_SIZE];

        char rmsg[MAX_MSG_SIZE];

        int index=0;

        int timeout = 100;

        int nBytes;

        int result = 0;

        int err = 0;

        int status = 0;

        int run_iso;

        FILE *fp;

        message_hdr_req *msgHdr = NULL;  

        message_hdr_resp* msg_struct = NULL;

        TInt return_value = 0;

        memset( smsg, '\0', MAX_MSG_SIZE );

        memset( rmsg, '\0', MAX_MSG_SIZE );

        //running isoserver   

        run_iso = run_isoserver(); 

        if(run_iso)

           {

           iLog->Log ( _L ( "running isolation server is failed" ) );

           return KErrGeneral;

            }             

         //create message queue for send request

        result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

           iLog->Log ( _L ( "creating requet queue is failed" ) );

           return KErrGeneral;

            }

       //create message queue for response request

        result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

            iLog->Log ( _L ( "creating requet queue is failed" ) );

            return KErrGeneral;

            }

            index=0;

            memset( smsg, '\0', MAX_MSG_SIZE );

            memset( rmsg, '\0', MAX_MSG_SIZE );

            msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

            memset( msgHdr, '\0', sizeof( message_hdr_req ) );

            msgHdr->message_type = EKill_Process;

            memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

            index += sizeof( message_hdr_req );

            result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

            free(msgHdr);           

           return KErrNone;

    }

TInt Cmessagequeue_api::TestMessageQDelete( CStifItemParser& aItem )

    {

        char smsg[MAX_MSG_SIZE];

        char rmsg[MAX_MSG_SIZE];

        int index=0;

        int timeout = 100;

        int nBytes;

        int result = 0;

        int err = 0;

        int status = 0;

        int run_iso;

        FILE *fp;

        message_hdr_req *msgHdr = NULL;  

        message_hdr_resp* msg_struct = NULL;

        TInt return_value = 0;

        memset( smsg, '\0', MAX_MSG_SIZE );

        memset( rmsg, '\0', MAX_MSG_SIZE );

        //running isoserver   

        run_iso = run_isoserver(); 

        if(run_iso)

           {

           iLog->Log ( _L ( "running isolation server is failed" ) );

           return KErrGeneral;

            }             

         //create message queue for send request

        result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

           iLog->Log ( _L ( "creating requet queue is failed" ) );

           return KErrGeneral;

            }

       //create message queue for response request

        result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

            iLog->Log ( _L ( "creating requet queue is failed" ) );

            return KErrGeneral;

            }

            index=0;

            memset( smsg, '\0', MAX_MSG_SIZE );

            memset( rmsg, '\0', MAX_MSG_SIZE );

            msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

            memset( msgHdr, '\0', sizeof( message_hdr_req ) );

            msgHdr->message_type = EKill_Process;

            memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

            index += sizeof( message_hdr_req );

            result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

            free(msgHdr); 

            result=MsgQDelete( REQUEST_QUEUE, &err );

            if(result)

                {

            iLog->Log ( _L ( "failing at message queue" ) );  

            return KErrGeneral;

                }

           return KErrNone;

    }

TInt Cmessagequeue_api::TestMessageQReceive( CStifItemParser& aItem )

    {

        char smsg[MAX_MSG_SIZE];

        char rmsg[MAX_MSG_SIZE];

        int index=0;

        int timeout = 100;

        int nBytes;

        int result = 0;

        int err = 0;

        int status = 0;

        int run_iso;

        FILE *fp;

        message_hdr_req *msgHdr = NULL;  

        message_hdr_resp* msg_struct = NULL;

        TInt return_value = 0;

        memset( smsg, '\0', MAX_MSG_SIZE );

        memset( rmsg, '\0', MAX_MSG_SIZE );

        //running isoserver   

        run_iso = run_isoserver(); 

        if(run_iso)

           {

           iLog->Log ( _L ( "running isolation server is failed" ) );

           return KErrGeneral;

            }             

         //create message queue for send request

        result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

           iLog->Log ( _L ( "creating requet queue is failed" ) );

           return KErrGeneral;

            }

       //create message queue for response request

        result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

        if(err)

           {

            iLog->Log ( _L ( "creating requet queue is failed" ) );

            return KErrGeneral;

            }

        //request formation 

            memset( smsg, '\0', MAX_MSG_SIZE );

            memset( rmsg, '\0', MAX_MSG_SIZE );

            //message header use

            msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

            memset( msgHdr, '\0', sizeof( message_hdr_req ) );

            msgHdr->message_type = ELogin_Request;

            memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

            index += sizeof( message_hdr_req );

            /* Send Message to queueOne */

            result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

            result = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, timeout, &err); 

                if (status < 0)

                {

                return  KErrGeneral;

                }

            index=0;

            memset( smsg, '\0', MAX_MSG_SIZE );

            memset( rmsg, '\0', MAX_MSG_SIZE );

            memset( msgHdr, '\0', sizeof( message_hdr_req ) );

            msgHdr->message_type = EKill_Process;

            memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

            index += sizeof( message_hdr_req );

            result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

            free(msgHdr); 

            result=MsgQDelete( REQUEST_QUEUE, &err );

            if(result)

                {

            iLog->Log ( _L ( "failing at message queue" ) );  

            return KErrGeneral;

                }

           return KErrNone;

    }

TInt Cmessagequeue_api::TestMessageQCheck( CStifItemParser& aItem )

    {

    char smsg[MAX_MSG_SIZE];

    char rmsg[MAX_MSG_SIZE];

    int index=0;

    int timeout = 100;

    int nBytes;

    int result = 0,r1=0 ,r2=0;

    int err = 0;

    int status = 0;

    int run_iso;

    FILE *fp;

    message_hdr_req *msgHdr = NULL;  

    message_hdr_resp* msg_struct = NULL;

    TInt return_value = 0;

    memset( smsg, '\0', MAX_MSG_SIZE );

    memset( rmsg, '\0', MAX_MSG_SIZE );

    //running isoserver   

    run_iso = run_isoserver(); 

    if(run_iso)

       {

       iLog->Log ( _L ( "running isolation server is failed" ) );

       return KErrGeneral;

        }             

     //create message queue for send request

    result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

    if(err)

       {

       iLog->Log ( _L ( "creating requet queue is failed" ) );

       return KErrGeneral;

        }

    //request formation 

        memset( smsg, '\0', MAX_MSG_SIZE );

        //message header use

        msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

        memset( msgHdr, '\0', sizeof( message_hdr_req ) );

        msgHdr->message_type = ELogin_Request;

        memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

        index += sizeof( message_hdr_req );

        /* Send Message to queueOne */

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

        r1 = MsgQCheck(REQUEST_QUEUE,&err);

        result = MsgQClean(REQUEST_QUEUE,&err);

        r2 = MsgQCheck(REQUEST_QUEUE,&err);

        if(r1==r2)

            {

            iLog->Log ( _L ( "message q clean  is failed" ) );

            return KErrGeneral;

            }

        index=0;

        memset( smsg, '\0', MAX_MSG_SIZE );

        memset( rmsg, '\0', MAX_MSG_SIZE );

        memset( msgHdr, '\0', sizeof( message_hdr_req ) );

        msgHdr->message_type = EKill_Process;

        memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

        index += sizeof( message_hdr_req );

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

        free(msgHdr); 

        result=MsgQDelete( REQUEST_QUEUE, &err );

        if(result)

            {

        iLog->Log ( _L ( "failing at message queue" ) );  

        return KErrGeneral;

            }

       return KErrNone;

}

TInt Cmessagequeue_api::TestMessageQClean( CStifItemParser& aItem )

    {

    char smsg[MAX_MSG_SIZE];

    char rmsg[MAX_MSG_SIZE];

    int index=0;

    int timeout = 100;

    int nBytes;

    int result = 0,r1=0 ,r2=0;

    int err = 0;

    int status = 0;

    int run_iso;

    FILE *fp;

    message_hdr_req *msgHdr = NULL;  

    message_hdr_resp* msg_struct = NULL;

    TInt return_value = 0;

    memset( smsg, '\0', MAX_MSG_SIZE );

    memset( rmsg, '\0', MAX_MSG_SIZE );

    //running isoserver   

    run_iso = run_isoserver(); 

    if(run_iso)

       {

       iLog->Log ( _L ( "running isolation server is failed" ) );

       return KErrGeneral;

        }             

     //create message queue for send request

    result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

    if(err)

       {

       iLog->Log ( _L ( "creating requet queue is failed" ) );

       return KErrGeneral;

        }

    //request formation 

        memset( smsg, '\0', MAX_MSG_SIZE );

        //message header use

        msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

        memset( msgHdr, '\0', sizeof( message_hdr_req ) );

        msgHdr->message_type = ELogin_Request;

        memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

        index += sizeof( message_hdr_req );

        /* Send Message to queueOne */

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

        result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

        r1 = MsgQCheck(REQUEST_QUEUE,&err);