/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp58.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkParser.h>

// CONSTANTS

#ifdef __WINS__

_LIT(KXMLFile, "z:\\system\\test\\testdata\\Tp49ImportInput.xml"); // re-use

#else

_LIT(KXMLFile, "c:\\system\\test\\testdata\\Tp49ImportInput.xml"); // re-use

#endif

_LIT(KTp58Panic, "Timeout Panic");

const TInt KTp58PanicNumber = 58;

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

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

// LOCAL_C ImportThreadFunction

//

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

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

//

LOCAL_C TInt ImportThreadFunction(TAny* aData)

    {

    CTrapCleanup* cleanup = CTrapCleanup::New(); 

    CActiveScheduler* actSch = new (ELeave) CActiveScheduler;

    CActiveScheduler::Install(actSch);

    TRAPD(err, CPosTp58::RunImportTestL(aData));

    delete actSch;

    delete cleanup;

    return err;

    }

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

// LOCAL_C KillerThreadFunction

//

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

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

//

LOCAL_C TInt KillerThreadFunction(TAny* aData)

    {

    CTrapCleanup* cleanup = CTrapCleanup::New(); 

    CActiveScheduler* actSch = new (ELeave) CActiveScheduler;

    CActiveScheduler::Install(actSch);

    TRAPD(err, CPosTp58::RunThreadKillerL(reinterpret_cast <RThread*> (aData)));

    delete actSch;

    delete cleanup;

    return err;

    }

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

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

// CPosTp58::GetName

//

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

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

//

void CPosTp58::GetName(TDes& aName) const

    {

    _LIT(KTestName, "TP58 - Import landmarks using User::WaitForRequest()");

    aName = KTestName;

    }

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

// CPosTp58::InitTestL

//

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

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

//

void CPosTp58::InitTestL()

    {

    MakeSurePanicDebugFileExistsL();

    }

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

// CPosTp58::CloseTest

//

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

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

//

void CPosTp58::CloseTest()

    {

    }

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

// CPosTp58::StartL

//

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

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

//

void CPosTp58::StartL()

    {

// Test Import all landmarks

    iLog->Put(_L("Importing all landmarks"));

    iTestCase = ETestImportAllLandmarks;

    iExpectedErrorCode = KErrGeneral;

    ResumeThreadsAndVerifyExitL();

// Test Import subset of landmarks

    iLog->Put(_L("Importing subset of all landmarks"));

    iTestCase = ETestImportSubsetOfLandmarks;

    iExpectedErrorCode = KErrGeneral;

    ResumeThreadsAndVerifyExitL();

    }

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

// CPosTp58::InitDbLC

//

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

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

//

CPosLandmarkDatabase* CPosTp58::InitDbLC()

    {

    RemoveDefaultDbL();

    CPosLandmarkDatabase* database = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(database);

    if (database->IsInitializingNeeded())

        {

        ExecuteAndDeleteLD(database->InitializeL());

        }

    return database;

    }

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

// CPosTp58::RunImportTestL

//

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

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

//

void CPosTp58::RunImportTestL(TAny* aData)

    {

    CPosTp58* tp58 = reinterpret_cast <CPosTp58*> (aData);

    switch (tp58->iTestCase)

        {

        case ETestImportAllLandmarks:

            tp58->ImportLandmarksL(NULL);

            break;

        case ETestImportSubsetOfLandmarks:

            {

            RArray<TUint> subset;

            CleanupClosePushL(subset);    

            subset.Append(5);

            subset.Append(1);

            subset.Append(9);

            subset.Append(3);

            tp58->ImportLandmarksL(&subset);

            CleanupStack::PopAndDestroy(&subset);

            }

            break;

        };

    }

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

// CPosTp58::RunThreadKillerL

//

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

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

//

void CPosTp58::RunThreadKillerL(RThread* aThread)

    {

    TTimeIntervalMicroSeconds32 oneMinute = 60 * 1000000;

    // Enter a infinite loop. This reason to this is that I want to be sure 

    // that it is killed by the TP58-thread.

    TBool forever = ETrue;

    while (forever)

        {

        User::After(oneMinute);

        // Panic importThread if it is still alive

        if (aThread->ExitType() == EExitPending)

            {

            TRequestStatus status;

            aThread->Logon(status);

            aThread->Panic(KTp58Panic, KTp58PanicNumber);

            User::WaitForRequest(status);

            }

        }

    }

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

// CPosTp58::ImportLandmarksL

//

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

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

//

void CPosTp58::ImportLandmarksL(const RArray<TUint>* aLandmarkSubSet)

    {

    CPosLandmarkDatabase* db = InitDbLC();

    // Recreate parser

    CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(KMimeType);

    CleanupStack::PushL(landmarkParser);

    landmarkParser->SetInputFileL(KXMLFile);

    CPosLmOperation* operation = NULL;

    if (aLandmarkSubSet)

        {

        // Import only a subset of the landmarks in parser

        operation = db->ImportLandmarksL(

            *landmarkParser, 

            *aLandmarkSubSet,  

            CPosLandmarkDatabase::EDefaultOptions);

        }

    else

        {

        operation = db->ImportLandmarksL(

            *landmarkParser, 

            CPosLandmarkDatabase::EDefaultOptions);

        }

    TRequestStatus status(KPosLmOperationNotComplete);

    TReal32 progress(0);

    operation->NextStep(status, progress);

    // Wait for NextStep to complete - should hang

    User::WaitForRequest(status);

    // Cancel the import operation

    delete operation;

    CleanupStack::PopAndDestroy(2, db);

    }

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

// CPosTp58::ResumeThreadsAndVerifyExitL

//

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

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

//

void CPosTp58::ResumeThreadsAndVerifyExitL()

    {

    iLog->Put(_L("ResumeThreadAndVerifyExitL"));

    _LIT(KCreateThreadErr, "Creating thread failed with %d");

	TBuf<100> threadName;

    // Create import thread

    RThread importThread;

    CleanupClosePushL(importThread);

    _LIT(KImportThreadName, "TP58 - Import thread, part %d");

    threadName.Format(KImportThreadName, iTestCase);

    iLog->Put(_L("Creating Import thread"));

    //TInt err = importThread.Create(KImportThreadName, ImportThreadFunction, 

    TInt err = importThread.Create(threadName, ImportThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, this);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    // Create killer thread

    RThread killerThread;

    CleanupClosePushL(killerThread);

    _LIT(KKillerThreadName, "TP58 - Killer thread, part %d");

    threadName.Format(KKillerThreadName, iTestCase);

    iLog->Put(_L("Creating Killer thread"));

    err = killerThread.Create(threadName, KillerThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &importThread);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    // Start threads and wait until either of them exits.

    TRequestStatus importThreadStatus, killerThreadStatus;

    importThread.Logon(importThreadStatus);

    importThread.Resume();

    killerThread.Logon(killerThreadStatus);

    killerThread.Resume();

    User::WaitForRequest(importThreadStatus, killerThreadStatus);

    // Kill the thread that might still be alive

    TExitType importThreadExitType = importThread.ExitType();

    TExitCategoryName importThreadExitCategory = importThread.ExitCategory();

    TInt importThreadExitReason = importThread.ExitReason();

    if (importThreadExitType == EExitPending)

        {

        importThread.Kill(KErrCancel);

        User::WaitForRequest(importThreadStatus);

        }

    TExitType killerThreadExitType = killerThread.ExitType();

    TExitCategoryName killerThreadExitCategory = killerThread.ExitCategory();

    TInt killerThreadExitReason = killerThread.ExitReason();

    if (killerThreadExitType == EExitPending)

        {

        killerThread.Kill(KErrCancel);

        User::WaitForRequest(killerThreadStatus);

        }

    // Log threads' exit results

    TBuf<100> buf;

    buf.Format(

        _L("ImportThread ended with exit type: %d, exit reason: %d, exit category: %S"), 

        importThreadExitType, importThreadExitReason, &importThreadExitCategory);

    iLog->Put(buf);

    buf.Format(

        _L("KillerThread ended with exit type: %d, exit reason: %d, exit category: %S"), 

        killerThreadExitType, killerThreadExitReason, &killerThreadExitCategory);

    iLog->Put(buf);

    // Verify thread exit results

    TBool error = VerifyThreadExitResults(killerThreadExitType, importThreadExitType, 

        importThreadExitCategory, importThreadExitReason);

    if (error)

        {

        User::Leave(KErrGeneral);

        }

    CleanupStack::PopAndDestroy(2, &importThread);

    }

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

// CPosTp58::VerifyThreadExitResults

//

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

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

//

TBool CPosTp58::VerifyThreadExitResults(

    TExitType aKillerThreadExitType,

    TExitType aImportThreadExitType,

    const TExitCategoryName& aImportThreadExitCategory,

    TInt aImportThreadExitReason)

    {

    TBool error = EFalse;

    if (aImportThreadExitType != EExitPanic)

        {

        _LIT(KExitTypeErr, "Import thread was not panicked as expected.");

        iLog->PutError(KExitTypeErr);

        error = ETrue;

        }

    if (aImportThreadExitCategory != KTp58Panic)

        {

        _LIT(KPanicErr, "Import thread had unexpected panic category");

        iLog->PutError(KPanicErr);

        error = ETrue;

        }

    if (aImportThreadExitReason != KTp58PanicNumber)

        {

        _LIT(KPanicCodeErr, "Import thread had unexpected panic number");

        iLog->PutError(KPanicCodeErr);

        error = ETrue;

        }

    if (aKillerThreadExitType != EExitPending)

        {

        _LIT(KExitTypeErr, "Killer thread was not alive as expected.");

        iLog->PutError(KExitTypeErr);

        error = ETrue;

        }

    return error;

    }

//  End of File