/*

* 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_CPosTp49.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkParser.h>

#include <Xml/XmlParserErrors.h>

// CONSTANTS

#ifdef __WINS__

_LIT(KFileWithCorrectSyntax, "z:\\system\\test\\testdata\\Tp49ImportInput.xml");

_LIT(KFileWithSyntaxError, "z:\\system\\test\\testdata\\Tp49ImportInputSyntaxError.xml");

#else

_LIT(KFileWithCorrectSyntax, "c:\\system\\test\\testdata\\Tp49ImportInput.xml");

_LIT(KFileWithSyntaxError, "c:\\system\\test\\testdata\\Tp49ImportInputSyntaxError.xml");

#endif

const TInt KNrOfImportedLandmarks = 7;

#ifdef __WINS__

const TInt KNrOfCorrectLandmarks = 3;

#else

const TInt KNrOfCorrectLandmarks = 4;

#endif

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

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

// CPosTp49::GetName

//

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

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

//

void CPosTp49::GetName(TDes& aName) const

    {

    _LIT(KTestName, "TP49 - Iterate imported landmarks");

    aName = KTestName;

    }

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

// CPosTp49::InitTestL

//

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

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

//

void CPosTp49::InitTestL()

    {

    RemoveDefaultDbL();

    RemoveAllLmDatabasesL();

    SetupPreConditionsL();

    }

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

// CPosTp49::CloseTest

//

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

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

//

void CPosTp49::CloseTest()

    {

    // Delete and set base class members to NULL

    delete iOperation;

    iOperation = NULL;

    delete iIterator;

    iIterator = NULL;

    delete iDatabase;

    iDatabase = NULL;

    delete iLandmarkParser;

    iImportedLandmarkIds.Close();

    iRemovedLandmarkIds.Close();

    delete iLandmarkNames;

    iLandmarkNames = NULL;

    }

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

// CPosTp49::NotifyProgress

//

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

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

//

void CPosTp49::NotifyProgress(TReal aProgress)

    {

    if (aProgress > iProgressInterruptLevel)

        {

        CActiveScheduler::Stop();

        }

    }

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

// CPosTp49::StartL

//

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

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

//

void CPosTp49::StartL()

    {

    // <<<<<<<<<<<<<< 1-2 Import unparsed landmarks >>>>>>>>>>>>>>>>>>>

    RecreateParserL(KFileWithCorrectSyntax);

    ImportAllLandmarksL();

    FetchIteratorL();

    VerifyImportedLandmarksL(KNrOfImportedLandmarks);

    // <<<<<<<<<<<<<< 3-5 Import parsed landmarks >>>>>>>>>>>>>>>>>>>

    RecreateParserL(KFileWithCorrectSyntax);

    ParseLandmarksContentL();

    ImportAllLandmarksL();

    FetchIteratorL();

    VerifyImportedLandmarksL(KNrOfImportedLandmarks);

    // <<<<<<<<<<<<<< 6-8 Remove some imported landmarks >>>>>>>>>>>>>>>>>>>

    RecreateParserL(KFileWithCorrectSyntax);

    ImportAllLandmarksL();

    FetchIteratorL();

    RemoveThreeLandmarksL();

    FetchIteratorL();

    VerifyImportedLandmarksL(KNrOfImportedLandmarks);

    // <<<<<<<<<<<<<< 9-10 Fetch iterator before import is ready >>>>>>>>>>>>>>>>>>>

    iProgressInterruptLevel = 0.5; // Cancel the import operation when half ready.

    TInt nrOfLandmarks = ImportSomeLandmarksL();

    // Cancel import operation, otherwise db will be locked when verifying

    delete iOperation; iOperation = NULL;

    VerifyImportedLandmarksL(nrOfLandmarks);

    // <<<<<<<<<<<<<< 11-12 Fetch iterator before import is started >>>>>>>>>>>>>>>>>>>

    iProgressInterruptLevel = 0; // Cancel the import operation as fast as possible.

    nrOfLandmarks = ImportSomeLandmarksL();

    // Cancel import operation, otherwise db will be locked when verifying

    delete iOperation; iOperation = NULL;

    VerifyImportedLandmarksL(nrOfLandmarks);

    // <<<<<<<<<<<<<< 13-14 Fetch iterator if import fails >>>>>>>>>>>>>>>>>>>

    RecreateParserL(KFileWithSyntaxError);

    StartImportLandmarksL();

    ExecuteLmOpL(EXmlTagMismatch);

    FetchIteratorL();

    CreateNameArrayL(KNrOfCorrectLandmarks);

    // We don't need to cancel operation since import operation failed. Hence 

    // it should release the database lock itself.

    // delete iOperation; iOperation = NULL;

    // Note: It seems that there is a difference between target and emulator in the number of imported 

    // landmarks in each next step, thus it differs in the number of imported lms before the incorrect xml-landmark

    // is found

    VerifyImportedLandmarksL(KNrOfCorrectLandmarks);

    // <<<<<<<<<<<<<< 15 Test leave codes - nothing to do >>>>>>>>>>>>>>>>>>>

    iLog->Put(_L("TP49 Done"));

	}

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

// CPosTp49::ImportAllLandmarksL

//

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

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

//

void CPosTp49::ImportAllLandmarksL()

    {

    // Fetch nr of existing items before import

    CPosLmItemIterator* iterator = iDatabase->LandmarkIteratorL();

    CleanupStack::PushL(iterator);

    TInt nrOfItems = iterator->NumOfItemsL();

    CleanupStack::PopAndDestroy(iterator);

    StartImportLandmarksL();

    ExecuteLmOpL(KErrNone);

    CreateNameArrayL(KNrOfImportedLandmarks);

    // Check nr of landmarks in db after import

    iterator = iDatabase->LandmarkIteratorL();

    CleanupStack::PushL(iterator);

    _LIT(KErrMsg, "Not all landmarks were imported to database!");

    TInt nrOfImportedItems = iterator->NumOfItemsL() - nrOfItems;

    AssertTrueSecL(

        nrOfImportedItems == KNrOfImportedLandmarks, KErrMsg, KErrGeneral);

    CleanupStack::PopAndDestroy(iterator);

    }

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

// CPosTp49::ImportSomeLandmarksL

//

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

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

//

TInt CPosTp49::ImportSomeLandmarksL()

    {

    RecreateParserL(KFileWithCorrectSyntax);

    StartImportLandmarksL();

    ExecuteLmOpL(KPosLmOperationNotComplete, ETrue);

    FetchIteratorL();

    CreateNameArrayL(iIterator->NumOfItemsL());

    return iIterator->NumOfItemsL();

    }

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

// CPosTp49::ParseLandmarksContentL

//

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

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

//

void CPosTp49::ParseLandmarksContentL()

    {

    delete iOperation;

    iOperation = NULL;

    iOperation = iLandmarkParser->ParseContentL();

    ExecuteLmOpL(KErrNone);

    }

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

// CPosTp49::RemoveThreeLandmarksL

//

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

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

//

void CPosTp49::RemoveThreeLandmarksL()

    {

    // It is important that the highest index is removed first.

    TInt indexToRemove[] = {6, 5, 2};

    const TInt KNrOfItemsToRemove = 3;

    _LIT(KErrMsg, "Removed landmark exists in database!");

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

        {

        User::LeaveIfError(

            iRemovedLandmarkIds.Append(iImportedLandmarkIds[indexToRemove[i]]));

        iLandmarkNames->Delete(indexToRemove[i]);

        iDatabase->RemoveLandmarkL(iImportedLandmarkIds[indexToRemove[i]]);

        // Verify landmark is removed

        CPosLandmark* lm = NULL;

        TRAPD(err, lm = iDatabase->ReadLandmarkLC(iImportedLandmarkIds[indexToRemove[i]]));

        delete lm;

        lm = NULL;

        AssertTrueSecL(err == KErrNotFound, KErrMsg, KErrGeneral);

        }

    }

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

// CPosTp49::VerifyImportedLandmarksL

//

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

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

//

void CPosTp49::VerifyImportedLandmarksL(TInt aNrOfExpectedItems)

    {

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

    // Iterate through all imported landmarks

    TInt i = 0;

    TPosLmItemId id = iIterator->NextL();

    while (id != KPosLmNullItemId)

        {

        CPosLandmark* lm = NULL;

        if (iRemovedLandmarkIds.Find(id) == KErrNotFound)

            {

            // The landmark has not been removed from database.

            // Try to read the imported landmark.

            lm = iDatabase->ReadLandmarkLC(id);

            // Verify that the landmark name exists in the name array.

            _LIT(KErrMsg, "Unexpected landmark name");

            _LIT(KErrMsg1, "GetLandmarkName returned KErrNotFound");

            TPtrC name;

            TInt res = lm->GetLandmarkName(name);

            if (res == KErrNotFound)

                {

                // No name found at all

                LogErrorAndLeave(KErrMsg1, KErrGeneral);

                }

            else

                {

                TInt index;

                iLog->Put(name);

                res = iLandmarkNames->Find(name, index);

                if (res != KErrNone)

                    {

                    // Found name does not match any name in the array.

                    LogErrorAndLeave(KErrMsg, KErrGeneral);

                    }

                }

            CleanupStack::PopAndDestroy(lm);

            }

        else

            {

            // The landmark has been removed from db. 

            // Verify that landmark does not exist in database.

            _LIT(KErrMsg, "Removed landmark exists in database!");

            TRAPD(err, lm = iDatabase->ReadLandmarkLC(id));

            delete lm;

            lm = NULL;

            AssertTrueSecL(err == KErrNotFound, KErrMsg, KErrGeneral);

            }

        i++;

        id = iIterator->NextL();

        }

    // Verify that length of iterator is equal to the nr of imported landmarks.

    _LIT(KErrMsg, "Nr of iterated landmarks did not match the nr of imported.");

    AssertTrueSecL(i == aNrOfExpectedItems, KErrMsg, KErrGeneral);

    }

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

// CPosTp49::SetupPreConditionsL

//

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

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

//

void CPosTp49::SetupPreConditionsL()

    {

    // Precondition: A non-empty database exists

    CPosLandmarkDatabase* db = OpenDatabaseLC();

    CleanupStack::Pop(db);

    iDatabase = db;

    ExecuteAndDeleteLD(iDatabase->CompactL());

    // Add one item to make it non-empty

    CPosLandmark* dummy = CPosLandmark::NewLC();

    iDatabase->AddLandmarkL(*dummy);

    CleanupStack::PopAndDestroy(dummy);

    }

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

// CPosTp49::ExecuteLmOpL

//

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

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

//

void CPosTp49::ExecuteLmOpL(TInt aExpectedResult, TBool aObserveProgress)

    {

    CActiveLmOperation* operationWrapper = 

        new (ELeave) CActiveLmOperation(iLog);

    CleanupStack::PushL(operationWrapper);

    if (aObserveProgress)

        {

        operationWrapper->Start(iOperation, this);

        }

    else 

        {

        operationWrapper->Start(iOperation);

        }

    CActiveScheduler::Start();

    if (aExpectedResult == KErrNone)

        {

        operationWrapper->CheckOperationL();

        }

    else

        {

        if (aExpectedResult != operationWrapper->Status())

            {

            _LIT(KErrMsg, "Expected result %d but got %d");

            TBuf<50> msg;

            msg.Format(KErrMsg, aExpectedResult, operationWrapper->Status());

            LogErrorAndLeave(msg, KErrGeneral);

            }

        }

    CleanupStack::PopAndDestroy(operationWrapper);

    }

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

// CPosTp49::FetchIteratorL

//

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

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

//

void CPosTp49::FetchIteratorL()

    {

    delete iIterator;

    iIterator = NULL;

    iIterator = iDatabase->ImportedLandmarksIteratorL(iOperation);

    TBuf<100> buf;

    iImportedLandmarkIds.Close();

    TInt nrOfItems = (TInt) iIterator->NumOfItemsL();

    buf.Format(_L("Retreving %d nr of ids from iterator"), nrOfItems);

    iLog->Put(buf);

    if (nrOfItems > 0)

        {

        iIterator->GetItemIdsL(iImportedLandmarkIds, 0, nrOfItems);

        }

    buf.Zero();    

    for (TInt i=0;i<iImportedLandmarkIds.Count();i++)

        {

        TBuf<15> idde;

        idde.Format(_L(" Id:%d "), iImportedLandmarkIds[i]);

        buf.Append(idde);

        }

    iLog->Put(buf);

    }

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

// CPosTp49::RecreateParserL

//

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

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

//

void CPosTp49::RecreateParserL(const TDesC& aFileName)

    {

    delete iLandmarkParser;

    iLandmarkParser = NULL;

    iLandmarkParser = CPosLandmarkParser::NewL(KMimeType);

    iLandmarkParser->SetInputFileL(aFileName);

    }

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

// CPosTp49::StartImportLandmarksL

//

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

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

//

void CPosTp49::StartImportLandmarksL()

    {

    delete iOperation;

    iOperation = NULL;

    iLog->Put(_L("Innan ImportLandmarksL"));

    iOperation = iDatabase->ImportLandmarksL(

        *iLandmarkParser, CPosLandmarkDatabase::EDefaultOptions);

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

    }

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

// CPosTp49::CreateNameArrayL

//

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

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

//

void CPosTp49::CreateNameArrayL(TInt aNrOfItems)

    {

    _LIT(KName0, "Landmark 0");

    _LIT(KName1, "Landmark 1");

    _LIT(KName2, "Landmark 2");

    _LIT(KName3, "Landmark 3");

    _LIT(KName4, "Landmark 4");

    _LIT(KName5, "Landmark 5");

    _LIT(KName6, "Landmark 6");

    const TDesC* names[] = {&KName0, &KName1, &KName2, &KName3, &KName4, 

        &KName5, &KName6};

    // Create array of landmark names. Names match those specified in the 

    // import file.

    delete iLandmarkNames;

    iLandmarkNames = new (ELeave) CDesCArrayFlat(8);

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

        {

        iLandmarkNames->AppendL(*names[i]);

        }

    }

//  End of File