/*

* Copyright (c) 2005 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: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp5.h"

#include <EPos_CPosLandmark.h> 

#include <LbsPosition.h>

#include <e32def.h> 

#include <e32std.h> 

#include <e32math.h>

#include "FT_LandmarkConstants.h"

// CONSTANTS

// _LIT(KGetNameErr, "GetLandmarks name returns incorrect error code");

_LIT(KNameErr, "Landmark name is incorrect");

_LIT(KIdErr, "Landmark Id is incorrect");

_LIT(KLongitudeErr, "Longitude is incorrect");

_LIT(KLatitudeErr, "Latitude is incorrect");

_LIT(KHorizontalAccErr, "Horizontal accuracy is incorrect");

_LIT(KVerticalAccErr, "Vertical accuracy is incorrect");

_LIT(KAltitudeErr, "Altitude is incorrect");

_LIT(KNumOfAvailablePositionFieldsErr, "NumOfAvailablePositionFields is incorrect");

_LIT(KNumOfategoriesErr, "Number of categories is incorrect");

_LIT(KCoverageRadiusErr, "CoverageRadius is incorrect"); 

_LIT(KIconIndexErr, "Icon index is incorrect");

_LIT(KIconMaskIndexErr, "Icon MaskIndex is incorrect");

_LIT(KMbmFileNameErr, "MbmFileName is incorrect");

_LIT(KDescriptionErr, "Description is incorrect");

_LIT(KPositionFieldErr, "Error in positions fields");

_LIT(KNameTp5, "Lm-Tp5");

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

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

// CPosTp5::StartL

//

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

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

//

void CPosTp5::StartL()

    { 

    _LIT(KNameTp5, "Lm-Tp5");

    RemoveDefaultDbL();

    CPosLandmark* landmark = CreateLandmarkLC(KNameTp5);

    CheckGetMethodsL(landmark);

    CheckRemoveMethodsL(landmark);

    CheckFieldsMaxLengthL();

    CleanupStack::PopAndDestroy(); // landmark

    CheckNaNErrorL();

    }

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

// CPosTp5::CheckGetMethods

//

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

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

//

void CPosTp5::CheckGetMethodsL(CPosLandmark* aLandmark)

    {

    TPtrC landmarkName;

    aLandmark->GetLandmarkName(landmarkName);  

    AssertTrueSecL(landmarkName.Compare(KNameTp5) == KErrNone, KNameErr);

    AssertTrueSecL(aLandmark->LandmarkId() == 0, KIdErr);

    CPosLandmarkDatabase* lmd = OpenDatabaseLC();

    TPosLmItemId id=lmd->AddLandmarkL(*aLandmark);

    AssertTrueSecL(aLandmark->LandmarkId() == id, KIdErr);

    TLocality loc2;

    aLandmark->GetPosition(loc2);

    AssertTrueSecL(loc2.Longitude() == KLongitude, KLongitudeErr);

    AssertTrueSecL(loc2.Latitude() == KLatitude, KLatitudeErr);

    AssertTrueSecL(loc2.HorizontalAccuracy() == KHorizontalAcc, KHorizontalAccErr);

    AssertTrueSecL(loc2.VerticalAccuracy() == KVerticalAcc, KVerticalAccErr);

    AssertTrueSecL(loc2.Altitude() == KAltitude, KAltitudeErr);

    TReal32 r;

    aLandmark->GetCoverageRadius(r);

    AssertTrueSecL(r == KCoverageRadius, KCoverageRadiusErr);

    TPtrC mbmFileName;

    TInt index;

    TInt indexMask;

    aLandmark->GetIcon(mbmFileName, index, indexMask);

    AssertTrueSecL(mbmFileName.Compare(KMbmFileName) == KErrNone, KMbmFileNameErr);

    AssertTrueSecL(index == KIconIndex, KIconIndexErr);

    AssertTrueSecL(indexMask == KIconMaskIndex, KIconMaskIndexErr);

    TPtrC desc;

    aLandmark->GetLandmarkDescription(desc);

    AssertTrueSecL(desc.Compare(KDescription) == KErrNone, KDescriptionErr);

    AssertTrueSecL(KNoPosFields == aLandmark->NumOfAvailablePositionFields(), KNumOfAvailablePositionFieldsErr);

    TPositionFieldId posFieldId = aLandmark->FirstPositionFieldId();

    for (TUint i=0; i<KNoPosFields-1; i++)

        {

        CheckPositionFieldL(*aLandmark, posFieldId);

        posFieldId=aLandmark->NextPositionFieldId(posFieldId);

        }

    RArray<TPosLmItemId> categories;

    CleanupClosePushL(categories);

    aLandmark->GetCategoriesL(categories);

    AssertTrueSecL(categories.Count() == KNoCategories, KNumOfategoriesErr);

    CleanupStack::PopAndDestroy(2,lmd); 

   	}

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

// CPosTp5::CheckRemoveMethodsL

//

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

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

//    

void CPosTp5::CheckRemoveMethodsL(CPosLandmark* aLandmark)

    {

    aLandmark->RemoveLandmarkAttributes(CPosLandmark::ENoAttribute);

    aLandmark->RemoveLandmarkAttributes(CPosLandmark::EPosition);

    aLandmark->RemoveLandmarkAttributes(CPosLandmark::ECoverageRadius);

    aLandmark->RemoveLandmarkAttributes(CPosLandmark::ECategoryInfo);

    aLandmark->RemoveLandmarkAttributes(CPosLandmark::EIcon);

    aLandmark->RemoveLandmarkAttributes(CPosLandmark::EDescription);

    CheckRemovedL(aLandmark);

    _LIT(KLandmarkName, "Nisse");

    CPosLandmark* landmark = CreateLandmarkLC(KLandmarkName);

    landmark->RemoveLandmarkAttributes(CPosLandmark::EAllAttributes);

    CheckRemovedL(landmark);

    TUint16 tmp = (TUint16)EPositionFieldMediaLinksStart;

    landmark->RemovePositionField(EPositionFieldMediaLinksStart);

    landmark->RemovePositionField(EPositionFieldCountry);

    landmark->RemovePositionField(EPositionFieldHorizontalSpeed);

    // FrBo Below has been removed

    landmark->RemovePositionField(EPositionFieldMediaLinks); 

    landmark->RemovePositionField(EPositionFieldMediaLinksStart); 

    landmark->RemovePositionField(++tmp);

    landmark->RemovePositionField(++tmp);

    landmark->RemovePositionField(EPositionFieldIdLast);

    TPtrC ptr;    

    AssertTrueSecL(landmark->GetPositionField(EPositionFieldMediaLinksStart, ptr) == KErrNotFound, KPositionFieldErr);

    AssertTrueSecL(landmark->GetPositionField(EPositionFieldCountry, ptr) == KErrNotFound, KPositionFieldErr);

    AssertTrueSecL(landmark->GetPositionField(EPositionFieldHorizontalSpeed, ptr) == KErrNotFound, KPositionFieldErr);

    // FrBo Below has been removed

    AssertTrueSecL(landmark->GetPositionField(EPositionFieldMediaLinks, ptr) == KErrNotFound, KPositionFieldErr); 

    AssertTrueSecL(landmark->GetPositionField(EPositionFieldMediaLinksStart, ptr) == KErrNotFound, KPositionFieldErr); 

    AssertTrueSecL(landmark->GetPositionField(++tmp, ptr) == KErrNotFound, KPositionFieldErr); 

    AssertTrueSecL(landmark->GetPositionField(++tmp, ptr) == KErrNotFound, KPositionFieldErr); 

    AssertTrueSecL(landmark->GetPositionField(EPositionFieldIdLast, ptr) == KErrNotFound, KPositionFieldErr); 

    // Remove some non-existing fields, nothing should happen

    landmark->RemovePositionField(6000);

    AssertTrueSecL(landmark->GetPositionField(6000, ptr) == KErrNotFound, KPositionFieldErr); 

    landmark->RemovePositionField(6001);

    AssertTrueSecL(landmark->GetPositionField(6001, ptr) == KErrNotFound, KPositionFieldErr); 

    CleanupStack::PopAndDestroy(); // landmark 

    }

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

// CPosTp5::CheckRemovedL

//

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

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

//

void CPosTp5::CheckRemovedL(CPosLandmark* aLandmark)

    {

    _LIT(KPositionRemovedErr, "GetPosition is not returning an error code when position is not set");

    TLocality loc;

    AssertTrueSecL(aLandmark->GetPosition(loc) == KErrNotFound, KPositionRemovedErr);

    RArray<TPosLmItemId> categories;

    CleanupClosePushL(categories);

    aLandmark->GetCategoriesL(categories);

    AssertTrueSecL(categories.Count() == 0, KNumOfategoriesErr);

    CleanupStack::PopAndDestroy(&categories);

    TReal32 r;

    AssertTrueSecL(aLandmark->GetCoverageRadius(r) == KErrNotFound, KCoverageRadiusErr);

    TPtrC mbmFileName;

    TInt index;

    TInt indexMask;

    AssertTrueSecL(aLandmark->GetIcon(mbmFileName, index, indexMask) == KErrNotFound, KMbmFileNameErr);

    TPtrC desc;

    AssertTrueSecL(aLandmark->GetLandmarkDescription(desc) == KErrNotFound, KDescriptionErr);

   }

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

// CPosTp5::CheckPositionFieldIdL

//

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

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

//

void CPosTp5::CheckPositionFieldL(const CPosLandmark& aLandmark, const TUint16 aId)

    {

    _LIT(KPositionFieldIdErr, "PositionFieldId is incorrect");

    _LIT(KComparePositionFieldValueErr, "PositionField value is different from set value");

    TUint16 tmp = (TUint16)EPositionFieldMediaLinksStart;

    TBuf<100> buf;

    buf.Format(_L("Looking for id:%d "),aId);

    iLog->Log(buf);

    TPtrC value;

    if (aId == EPositionFieldCountry)

        {

        aLandmark.GetPositionField(aId, value);             

        AssertTrueSecL(value.Compare(KCountry) == KErrNone, KComparePositionFieldValueErr);

        }

    else if (aId == EPositionFieldHorizontalSpeed)

        {

        aLandmark.GetPositionField(aId, value);

        AssertTrueSecL(value.Compare(KHorizontalSpeed) == KErrNone, KComparePositionFieldValueErr);

        }

    else if (aId == EPositionFieldMediaLinks)

        {

        aLandmark.GetPositionField(aId, value);

        AssertTrueSecL(value.Compare(KMediaLinks) == KErrNone, KComparePositionFieldValueErr);

        }

    else if (aId == EPositionFieldMediaLinksStart)

        {

        aLandmark.GetPositionField(aId, value);

        AssertTrueSecL(value.Compare(KMediaLink1) == KErrNone, KComparePositionFieldValueErr);

        iLog->Log(_L("EPositionFieldMediaLinksStart"));

        }

    else if (aId == EPositionFieldIdLast)

        {

        aLandmark.GetPositionField(aId, value);

        AssertTrueSecL(value.Compare(KLast) == KErrNone, KComparePositionFieldValueErr);

        }

    else if (aId == (tmp+1))

        {

        aLandmark.GetPositionField(aId, value);

        AssertTrueSecL(value.Compare(KMediaLink2) == KErrNone, KComparePositionFieldValueErr);

        }

    else if(aId == (tmp+2)) 

        {

        aLandmark.GetPositionField(aId, value);

        AssertTrueSecL(value.Compare(KMediaLink3) == KErrNone, KComparePositionFieldValueErr);

        }

    else

        {

        buf.Format(_L("Looking for id: %d %d %d"), aId, (tmp+1), (tmp+2));

        iLog->Log(buf);

        iLog->Log(KPositionFieldIdErr);

        User::Leave(KErrGeneral);

        }

     }

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

// CPosTp5::CheckFieldsMaxLength

//

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

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

//

void CPosTp5::CheckFieldsMaxLengthL()

    {

    _LIT(K255Error, "Text field is not limited to 255 characters");

    _LIT(K4095Error, "Description field is not limited to 4095 characters");

    _LIT(KIconError, "Icon File Name field is not limited to correct nr of characters");

    HBufC* hbuf = HBufC::NewLC(4096);

    while(hbuf->Des().Length() < 255)

        {

        hbuf->Des().Append(_L("X"));

        }

    CPosLandmark* landmark = CPosLandmark::NewLC();

    landmark->SetLandmarkNameL(*hbuf);

    landmark->SetLandmarkDescriptionL(*hbuf);      

    landmark->SetPositionFieldL(EPositionFieldCountry, *hbuf);

    hbuf->Des().Append(_L("X"));

    TRAPD(err, landmark->SetLandmarkNameL(*hbuf));

    AssertTrueSecL(err == KErrArgument, K255Error);

    landmark->SetLandmarkDescriptionL(*hbuf);      

    TRAP(err, landmark->SetPositionFieldL(EPositionFieldCountry, *hbuf));

    AssertTrueSecL(err == KErrArgument, K255Error);

    while(hbuf->Des().Length() < 4095)

       {

        hbuf->Des().Append(_L("X"));

       }

    landmark->SetLandmarkDescriptionL(*hbuf);      

    hbuf->Des().Append(_L("X"));

    TRAP(err, landmark->SetLandmarkDescriptionL(*hbuf));      

    AssertTrueSecL(err == KErrArgument, K4095Error);

    CleanupStack::PopAndDestroy(2, hbuf);

    // Test setIconL

    // KMaxFileName is defined in e32const.h

    HBufC* icon = HBufC::NewLC(KMaxFileName+1);

    while(icon->Des().Length() < KMaxFileName)

        {

        icon->Des().Append(_L("X"));

        }

    landmark = CPosLandmark::NewLC();

    landmark->SetLandmarkNameL(_L("SomeLandmarkName"));

    landmark->SetLandmarkDescriptionL(_L("SomeLandmarkDescription"));

    landmark->SetIconL(*icon, 1, KPosLmIconMaskNotUsed);

    icon->Des().Append(_L("X"));

    TRAP(err, landmark->SetIconL(*icon, 1, KPosLmIconMaskNotUsed));

    AssertTrueSecL(err == KErrArgument, KIconError);

    CleanupStack::PopAndDestroy(landmark);

    CleanupStack::PopAndDestroy(icon); 

    }

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

// CPosTp5::CheckNaNErrorL

//

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

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

//

void CPosTp5::CheckNaNErrorL()

    {

    iLog->Log(_L("CheckErrorL"));

    CPosLandmarkDatabase* lmdb = OpenDatabaseLC();

    CPosLandmark* landmark = CPosLandmark::NewLC();

    ExecuteAndDeleteLD(lmdb->CompactL());

    TInt errorsFound = KErrNone;

    TRealX NaN;

    NaN.SetNaN();

    // Used for testing SDK:

    // This part should result in log:

    // Not Equal1

    // Not Equal2

    TRealX pos1;

    TRealX pos2;

    iLog->Log(_L("Testing with NaN and 45"));

    pos1.SetNaN();

    pos2 = 45;

    if (pos2 == pos1) 

        iLog->Log(_L("Equal1"));

        else

        iLog->Log(_L("Not Equal1"));

    if (pos2 != pos1) 

        iLog->Log(_L("Not Equal2"));

        else

        iLog->Log(_L("Equal2"));

    iLog->Log(_L("Testing with NaN and 0"));

    pos1.SetNaN();

    pos2 = 0;

    if (pos2 == pos1) 

        iLog->Log(_L("Equal1"));

        else

        iLog->Log(_L("Not Equal1"));

    if (pos2 != pos1) 

        iLog->Log(_L("Not Equal2"));

        else

        iLog->Log(_L("Equal2"));

    iLog->Log(_L("Testing with NaN and NaN"));

    pos1.SetNaN();

    pos2.SetNaN();

    if (pos2 == pos1) 

        iLog->Log(_L("Equal1"));

        else

        iLog->Log(_L("Not Equal1"));

    if (pos2 != pos1) 

        iLog->Log(_L("Not Equal2"));

        else

        iLog->Log(_L("Equal2"));

    landmark->SetLandmarkNameL(_L("TestingLandmarkError"));

    // Only set position with Latitude and Longitude (thus Altitude and Accuracy is NaN)

    TLocality loc;

    loc.SetCoordinate(1,2);

    landmark->SetPositionL(loc);

    TPosLmItemId myId = lmdb->AddLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////

    // Test Altitude

    landmark = lmdb->ReadLandmarkLC(myId);    

    landmark->GetPosition(loc);

    loc.SetCoordinate(1,2, 123);

    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);

    TLocality loc3;

    landmark->GetPosition(loc3);

    if (TRealX(loc3.Altitude()).IsNaN())

        {

        iLog->Log(_L("Error: Altitude is Nan"));

        errorsFound++;

        }

    else if (loc3.Altitude() != 123)

        {

        iLog->Log(_L("Error: Incorrect altitude returned"));

        errorsFound++;

        }

    // Reset landmark

    loc.SetCoordinate(1,2, NaN);

    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////

    // Test Horizontal accuracy

    landmark = lmdb->ReadLandmarkLC(myId);

    loc.SetCoordinate(1,2, NaN);

    loc.SetHorizontalAccuracy(12);

    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);

    landmark->GetPosition(loc3);

    if (TRealX(loc3.HorizontalAccuracy()).IsNaN())

        {

        iLog->Log(_L("Error: Horizontal accuracy is Nan"));

        errorsFound++;

        }

    else if (loc3.HorizontalAccuracy() != 12)

        {

        iLog->Log(_L("Error: Incorrect horizontal accuracy returned"));

        errorsFound++;

        }

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////

    // Test with NaN for hor acc

    landmark = lmdb->ReadLandmarkLC(myId);

    loc.SetCoordinate(1,2, NaN);

    loc.SetHorizontalAccuracy(NaN);

    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);

    landmark->GetPosition(loc3);

    if (TRealX(loc3.HorizontalAccuracy()).IsNaN())

        {

        iLog->Log(_L("Horizontal accuracy is correctly set to Nan"));

        }

    else

        {

        iLog->Log(_L("Error: Incorrect horizontal accuracy returned"));

        errorsFound++;

        }

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////

    // Test Vertical accuracy

    landmark = lmdb->ReadLandmarkLC(myId);

    loc.SetCoordinate(1,2, NaN);

    loc.SetVerticalAccuracy(21);

    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);

    landmark->GetPosition(loc3);

    if (TRealX(loc3.VerticalAccuracy()).IsNaN())

        {

        iLog->Log(_L("Error: Vertical accuracy is Nan"));