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

// Example CTestStep derived implementation

//

/**

 @file testsignaling.cpp

 @internalTechnology

*/

#include <crashdatasave.h>

#include <s32file.h>

#include <bautils.h>

#include "testsignaling.h"

#include "tcoredumpserversuitedefs.h"

#include "tcoredumpserverSuiteServer.h"

/* Null UID set for ECrashProgress which does not have UID */

const TUint KNULLUID = 999;

/**

 * Constructor

 */

CTestSignaling::CTestSignaling()

    {

    // **MUST** call SetTestStepName in the constructor as the controlling

    // framework uses the test step name immediately following construction to set

    // up the step's unique logging ID.

    SetTestStepName (KTestSignaling);

    }

/**

 * Destructor

 */

CTestSignaling::~CTestSignaling()

    {

    }

/**

 * @return - TVerdict code

 * Override of base class virtual

 * establishing connection to core dump server and file server

 * Property handles created and also the corresponding buffers

 */

TVerdict CTestSignaling::doTestStepPreambleL()

    {

    TInt ret = KErrNone;

    SetTestStepResult (EPass);

    ret = iSess.Connect ();

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iSess->Connect()/n"), ret);

        User::Leave(ret);

        }

    ret = iFs.Connect ();

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iFs->Connect()/n"), ret);

        User::Leave(ret);

        }

    ret = iCrashProgress.Attach(KCoreDumpServUid, ECrashProgress);

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iCrashProgress.Attach()/n"), ret);

        User::Leave(ret);

        }

    ret = iCrashMediaName.Attach(KCoreDumpServUid, ECrashMediaName);

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iCrashMediaName.Attach()/n"), ret);

        User::Leave(ret);

        }

    ret = iCrashCancel.Attach(KCoreDumpServUid, ECancelCrash);

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iCrashCancel.Attach()/n"), ret);

        User::Leave(ret);

        }

    ret = iCrashProgressBuffer.Create(KMaxCrashProgressBuffer);

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iCrashProgressBuffer.Create()/n"), ret);

        User::Leave(ret);

        }

    ret = iCrashMediaNameBuffer.Create(KNumofEntries * KMaxEntryLength);

    if ( ret != KErrNone)

        {

        SetTestStepResult ( EFail);

        ERR_PRINTF2 (_L ("Error %d from iCrashMediaNameBuffer.Create()/n"), ret);

        User::Leave(ret);

        }

    return TestStepResult();

    }

/**

 * @return - TVerdict code

 * Override of base class virtual

 * releasing the sessions to the servers

 * closing the RProperty handles and buffers

 */

TVerdict CTestSignaling::doTestStepPostambleL()

    {

    iSess.Disconnect();

    User::After(10000000); //ensure we give enough time for session to close

    iFs.Close();

    iCrashProgress.Close();

    iCrashMediaName.Close();

    iCrashCancel.Close();

    iCrashProgressBuffer.Close();

    iCrashMediaNameBuffer.Close();

    return EPass;

    }

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value will be EPass.

 */

TVerdict CTestSignaling::doTestStepL()

    {

    if(TestStepResult() == EPass)

        {

        TInt ret = KErrNone;

        __UHEAP_MARK;

        TRAP (ret, ClientAppL ());

        if (KErrNone != ret)

            {

            SetTestStepResult (EFail);

            ERR_PRINTF2 (

                    _L ("Error %d from CTestFormatterUserSideStep->ClientAppL()"),

                    ret);

            User::Leave(ret);

            }

        __UHEAP_MARKEND;

        }

    return TestStepResult ();

    }

/**

 * @return void

 * This calls each stage of the test

 */

void CTestSignaling::ClientAppL()

    {

    INFO_PRINTF1 (_L ("Starting Test Signaling Mechanism Test Suite"));

    TestSignalingMechanismL();

    }

/**

 * @return void

 * Tests the signaling mechanism through RProperty updates

 * checks for the crash progress and crash media name property updates

 */

void CTestSignaling::TestSignalingMechanismL()

    {

    if (TestStepResult() == EPass)

        {

        //reading configuration from the ini file

        TPtrC crashAppParam;

        TPtrC crashFileName;

        TPtrC testNumberofCrashes;

        if(!GetStringFromConfig(ConfigSection(), KTe_CrashAppParam, crashAppParam) ||

           !GetStringFromConfig(ConfigSection(), KTe_CrashFileName, crashFileName) ||

           !GetStringFromConfig(ConfigSection(), KNumberofCrashes, testNumberofCrashes))

            {

            ERR_PRINTF1(_L("Failed to get data from the ini file"));

            SetTestStepResult(EFail);

            User::Leave(KErrGeneral);

            }

        //Convert number of crashes

        TLex luther(testNumberofCrashes);

        User::LeaveIfError(luther.Val(iTimestoCrash));

        if(iTimestoCrash < KNumofEntries)

            {

            ERR_PRINTF3(_L ("Expecting the number of crashes %d to be more than %d"), iTimestoCrash, KNumofEntries);

            SetTestStepResult(EFail);

            User::Leave(KErrGeneral);

            }

        INFO_PRINTF2(_L("Number of crashes to happen %d"), iTimestoCrash);

        iCrashFileName.Copy(crashFileName);

        // setting the crash media name to zero

        // ** caution this is just done for testing **

        ZeroCrashMediaNameL();

        // Load the SELF Formatter and File Writer

        LoadandConfigurePluginsL(crashFileName);

        //lets do the first crash

        //start the application that would crash and observe it

        StartCrashAppL(crashAppParam);

        // check for the presence of UID in the crash progress messages

        CheckUIDCrashProgressL();

        iNumberofCrashes++;

        // breather -- TODO: Why is this here? Document or remove

        User::After(1000000);

        // create more crashes to create iTimestoCrash - 1 crashes

        // and check the ECrashMediaName buffer content

        for (TInt i = 0; i < (iTimestoCrash - 1); i++ )

            {

            StartCrashAppL(crashAppParam);

            //CheckUIDCrashProgressL();

            CheckCrashMediaNameL();

			// TODO: Why is this here? Document or remove

            User::After(1000000);

            }

        // now we have done multiple crashes

        // and we would like to investigate the crash media name buffer

        TestCrashMessageBufferL();

        //now going to test the cancel crash scenario

        StartCrashAppL(crashAppParam);

        CheckCancelCrashL();

		TidyFilesL(crashFileName);

        INFO_PRINTF1 (_L ("\nSuccessfully tested the signaling mechanism! Adios!\n"));

        }

    }

/**

 * Deletes the crash files generated by this test to prevent corruption

 * of future test

 * @param aFilenameRoot root of filename to remove (we will remove aFilenameRoot*)

 * @leave One of the system wide error codes

 */

void CTestSignaling::TidyFilesL(const TDesC& aFilenameRoot)

	{

	_LIT(KWildCardMatch, "*");

	TBuf<KMaxFileName> file;

	file.Append(aFilenameRoot);

	file.Append(KWildCardMatch);

	BaflUtils::DeleteFile(iFs, file);

	}

/**

 * @return void

 * @param parameters for crashapp/exe

 * Starts the crashapp.exe and observe for the crash via CDS

 */

void CTestSignaling::StartCrashAppL(const TDesC& aCrashAppParam)

    {

    INFO_PRINTF2(_L ("Executing crashapp.exe %S \n"), &aCrashAppParam);

    //Start the process that we intend to crash....

    RProcess crashProcess;

    CleanupClosePushL (crashProcess);

    TInt ret = crashProcess.Create(KCrashAppFileName, aCrashAppParam);

    if ( ret != KErrNone)

        {

        ERR_PRINTF2 (

             _L ("Error %d from RProcess.Create(z:\\sys\\bin\\crashapp.exe)/n"),

             ret);

        SetTestStepResult (EFail);

        User::Leave(ret);

        }

    // Observe the process and wait for a crash

    TRAP (ret, iSess.ObservationRequestL( KCrashAppFileName, KCrashAppFileName, ETrue));

    if ( ret != KErrNone)

      {

      ERR_PRINTF2 (

              _L ("Error %d iSess.ObservationRequestL(z:\\sys\\bin\\crashapp.exe)\n"),

              ret);

      SetTestStepResult(EFail);

      User::Leave(ret);

      }

    //start the crash process

    crashProcess.Resume ();

    CleanupStack::PopAndDestroy (&crashProcess);

    }

/**

 * @return void

 * Check for the presence of UID in the crash progress messages

 * also check for messages if they have the same crash UID

*/

void CTestSignaling::CheckUIDCrashProgressL()

    {

    INFO_PRINTF1(_L ("Subscribing and Reading ECrashProgress Messages"));

    TUint uid = 0;

    TUint saveduid = KNULLUID;

    TRequestStatus status;

    TInt i = 0;

    iCrashProgressBuffer.Zero();

    User::LeaveIfError(iCrashProgress.Get(iCrashProgressBuffer));

    // read the crash UID and the crash progress message present

    ReadCrashProgressPacketL(uid, iCrashProgressBuffer);

    if(uid != KNULLUID)

        {

        ERR_PRINTF1(_L("First crashprogress message should no crash uid in it"));

        SetTestStepResult(EFail);

        User::Leave(KErrGeneral);

        }

    INFO_PRINTF2(_L ("CrashProgress Messages %S"), &iCrashProgressBuffer);

    //Now we read the crash progress messages until the processing is finished

    do

        {

        i++;

        //start the subscription to see change in the property ECrashProgress

        iCrashProgress.Subscribe(status);

        User::WaitForRequest (status);

        User::LeaveIfError(iCrashProgress.Get(iCrashProgressBuffer));

        INFO_PRINTF2(_L ("CrashProgress Messages %S"), &iCrashProgressBuffer);

        // read the crash UID and the crash progress message present

        ReadCrashProgressPacketL(uid, iCrashProgressBuffer);

        // check for first message to be "Start"

        if ( (1 == i) &&  (iCrashProgressBuffer.CompareF(_L("Start")) != 0) )

            {

            // the first message has to be Start

            ERR_PRINTF2(_L("First crashprogress message %S should have Start in it"), &iCrashProgressBuffer);

            SetTestStepResult(EFail);

            User::Leave(KErrGeneral);

            }

        else if ( (1 == i) &&  (iCrashProgressBuffer.CompareF(_L("Start")) == 0) )

            {

            // save the crash UID for future checks

            if (uid != KNULLUID)

                SaveCrashUIDL(uid);

            }

        else if( (saveduid != KNULLUID) && (uid != KNULLUID) )

            {

            // chec if all the messages do have the same crash UID

            if(saveduid != uid)

                {

                ERR_PRINTF3(_L("Mismatch in the UID values saveduid %S does not match with uid %S"), saveduid, uid);

                SetTestStepResult(EFail);

                User::Leave(KErrGeneral);

                }

            }

        saveduid = uid;

        }

    while(iCrashProgressBuffer != KEndOfProcessing);

    iCrashProgressBuffer.Zero();

    INFO_PRINTF1(_L ("Succesful Read all the ECrashProgress Messages"));

    }

/**

 * @return void

 * Check for the the crash media name messages

 * parses the values and validates the crash media name and the status bit

*/

void CTestSignaling::CheckCrashMediaNameL()

    {

    INFO_PRINTF1(_L ("Validate the Crash Media Name Messages"));

    TUint crashUID = 0;

    TBuf<KMaxStatusLength> statusbit;

    TRequestStatus status;

    do

        {

        // subscribe to the Crash Progress Property

        // intention is to be notified of the crash processing start

        iCrashProgress.Subscribe(status);

        User::WaitForRequest(status);

        User::LeaveIfError(iCrashProgress.Get(iCrashProgressBuffer));

        // extract the crash UID and the crash progress message

        ReadCrashProgressPacketL(crashUID, iCrashProgressBuffer);

        if(iCrashProgressBuffer.CompareF(_L("Start")) == 0)

            {

            // now read the crash media name which should be updated

            // no need to subscribe for ECrashMediaName as it has already been updated

            User::LeaveIfError(iCrashMediaName.Get(iCrashMediaNameBuffer));

            INFO_PRINTF2(_L ("Crash Media Name Messages %S"), &iCrashMediaNameBuffer);

            // read the crash media name entry for the particular crash uid

            ParseMediaNameBufferL(crashUID, iCrashMediaNameBuffer, statusbit);

            //check if the crash status bit "I" i.e it is still In Progress

            if(statusbit.CompareF(_L("I")) != 0)

                {

                ERR_PRINTF2(_L("Incorrect status bit %S expecting it to be I"), &statusbit);

                SetTestStepResult(EFail);

                User::Leave(KErrGeneral);

                }

            // check if the CrashFile name is valid name

            iCrashFileName.Append(_L("*"));

            if (iCrashMediaNameBuffer.MatchF(iCrashFileName) == KErrNotFound)

                {

                ERR_PRINTF3(_L("Crash Media Name %S does not match with %S"), &iCrashFileName, &iCrashMediaNameBuffer);

                SetTestStepResult(EFail);

                User::Leave(KErrGeneral);

                }

            // happy to save the crash UID for future checks

            SaveCrashUIDL(crashUID);

            }

        }

    while(iCrashProgressBuffer != KEndOfProcessing);

    //now check the status bit message

    User::LeaveIfError(iCrashMediaName.Get(iCrashMediaNameBuffer));

    INFO_PRINTF2(_L ("Crash Media Name Messages %S"), &iCrashMediaNameBuffer);

    // parse the crash media name message

    ParseMediaNameBufferL(iCrashUID[iNumberofCrashes - 1], iCrashMediaNameBuffer, statusbit);

    //check if the crash status bit "D" i.e the crash processing is now done

    if(statusbit.CompareF(_L("D")) != 0)

        {

        ERR_PRINTF2(_L("Incorrect status bit %S supposed to be D"), &statusbit);

        SetTestStepResult(EFail);

        User::Leave(KErrGeneral);

        }

    INFO_PRINTF1(_L ("Successful checked the Crash Media Name Messages"));

    }

/**

 * @return void

 * Check for the the crash media name messages after multiple crashes has happened

 * expects that the number of crashes is more than the KNumofEntries

 * parses the crash media name buffer and validates the status bit

 * also checks if we have all the latest crashes in the crash media buffer

*/

void CTestSignaling::TestCrashMessageBufferL()

    {

    INFO_PRINTF1(_L ("Test the final Crash Media Name Message Buffer"));

    // read the crash media name buffer

    iCrashMediaNameBuffer.Zero();

    User::LeaveIfError(iCrashMediaName.Get(iCrashMediaNameBuffer));

    INFO_PRINTF2(_L("Final Crash Media name Buffer %S"), &iCrashMediaNameBuffer);

    TInt numofEntries = iCrashMediaNameBuffer.Length() / KMaxEntryLength;

    // expects that the number of crashes is greater than  KNumofEntries

    if (numofEntries != KNumofEntries)

        {

        ERR_PRINTF2(_L("%d Entries is not equal to the max length"), numofEntries);

        SetTestStepResult(EFail);

        User::Leave(KErrGeneral);

        }

    // check for the buffer consistency

    if( (iCrashMediaNameBuffer.Length() % KMaxEntryLength) != 0  )

        {

        ERR_PRINTF2(_L("Buffer corrupt iCrashMediaNameBuffer.Length() %d"), iCrashMediaNameBuffer.Length());

        SetTestStepResult(EFail);

        User::Leave(KErrGeneral);

        }

    // run through the buffer

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

        {

        // check for the status bit

        // used as a bit to check on the validity of the entry

        TPtrC statusptr = iCrashMediaNameBuffer.Mid((i * KMaxEntryLength), KMaxStatusLength);

        if ((statusptr.CompareF(_L("D")) != 0) )

          {

          ERR_PRINTF2(_L("Entry Number %d does not seem to have complete status"), i);

          SetTestStepResult(EFail);

          User::Leave(KErrGeneral);

          }