// Copyright (c) 2001-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:

//

//  INCLUDES

#include "ctlbscalculationtp236.h"

#include "tlbscalculationcheck.h"

// C++ constructor 

CT_LbsCalculationTP236::CT_LbsCalculationTP236(CT_LbsCalculationServer& aParent) : CT_LbsCalculationStepBase(aParent)

    {

    _LIT(KTestName, "Calculation TP236 - Coordinate Move");

    SetTestStepName(KTestName);

    }

CT_LbsCalculationTP236::~CT_LbsCalculationTP236()

    {

    }

CT_LbsCalculationTP236* CT_LbsCalculationTP236::New(CT_LbsCalculationServer& aParent)

    {

    CT_LbsCalculationTP236* testStep = new CT_LbsCalculationTP236(aParent);

    // Note the lack of ELeave.

    // This means that having insufficient memory will return NULL;

    if (testStep)

        {

        TInt err = KErrNone;

        TRAP(err, testStep->ConstructL());

        if (err)

            {

            delete testStep;

            testStep = NULL;

            }

        }

    return testStep;

    }

TVerdict CT_LbsCalculationTP236::doTestStepL()

    {

    TestValuesL();

    return TestStepResult();

    }

void CT_LbsCalculationTP236::TestValuesL()

    {   

    _LIT(KOpenFailed, "File open failed with %d");

    TInt err=0; 

    err=ReadValues();

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

    TInt index=5;

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

        {  

        T_LbsCalculationCheck cc = iCalculationChecks[i];    

        if (index==10) 

            cc.CheckMove();

        err=cc.CheckMove();

        LogError(err==KErrNone, cc, err, index);

        ++index;

        if (index == 21 || index == 26 || index == 33 || index == 38|| index == 40 || index == 45 || 

            index == 50 || index == 73 || index == 78 || index == 85 || index == 92 || index == 96 || 

            index == 33 || index == 106 || index == 123 || index == 128 || index == 133)

            {

            ++index;

            }

        }

    // Checks that KErrArgumenet is returned

    T_LbsCalculationCheck c;

    err=c.CheckMove();

    LogError(err==KErrNone, c, err);

    //

    // Test error report SBUY-65KBZD TCoordinate::Move returns wrong results

    // Note that the same calculation error is found in the calculations in the excel sheet

    // Therefore we need to test it here

    TCoordinate source(0, 0);

    TCoordinate target(0, 99);

    err=source.Move(90, 11000000);

    _LIT(KInfoMsg1, "Testing SBUY-65KBZD");

    INFO_PRINTF1(KInfoMsg1);

    // Sert accuracy to very low

    const TReal KAccuracy = 0.5;

    if (!Equals(source.Latitude(), target.Latitude(), KAccuracy) ||

        !Equals(source.Longitude(), target.Longitude(), KAccuracy))

        {

        _LIT(KErrorMsg1, "Move of TC(0,0) bearing 90, 11000000 meters returned wrong coord");

        LogErrorAndLeaveL(KErrorMsg1);

        }

    //

    TCoordinate source2(0, 0);

    TCoordinate target2(0, -90);

    err=source2.Move(90, 30000000);

    if (!Equals(source2.Latitude(), target2.Latitude(), KAccuracy) ||

        !Equals(source2.Longitude(), target2.Longitude(), KAccuracy))

        {

        _LIT(KErrorMsg2, "Move of TC(0,0) bearing 90, 30000000 meters returned wrong coord");

        LogErrorAndLeaveL(KErrorMsg2);

        }        

    //

    }

TBool CT_LbsCalculationTP236::Equals(const TReal aValue1, const TReal aValue2, const TReal aAccuracy)

    {

    TReal maxAllowedError = aAccuracy;

    TReal absError = Abs(aValue1-aValue2);

    return (absError < maxAllowedError); 

    }

void CT_LbsCalculationTP236::TestNotSupportedL()

    {

    T_LbsCalculationCheck c;

    c.SetMoveErrorCode(KErrNotSupported);

    TInt err=c.CheckMove();

    LogError(err==KErrNone, c, err);     

    }

void CT_LbsCalculationTP236::LogTestError(const T_LbsCalculationCheck& aCalc, 

                                     const TInt aError,

                                     const TInt aRow)

    {

    TBuf<KMaxLogLineLength> buf;

    TPosition source;

    TPosition target;

    aCalc.GetSourcePosition(source);

    aCalc.GetTargetPosition(target);

    if (aError==KErrCalculationCheckMove)

        {

        TCoordinate calcCoordinate;

        aCalc.GetCalcCoordinate(calcCoordinate);

        _LIT(KSpeedError, "Calculated coordinate is not equal to read target coordinate, values:");

        _LIT(KValues, "Read coordinate: Lat= %f, Long2= %f, calulated coordinate: Lat= %f, Long= %f, row %d"); 

		buf.Format(KValues, target.Latitude(), 

                            target.Longitude(), 

                            calcCoordinate.Latitude(), 

                            calcCoordinate.Longitude(),

                            aRow);

        ERR_PRINTF1(KSpeedError);

        }

     else if(aError==KErrCalculationCheckErrorCode)

        {

        _LIT(KIncorrectErrorCode, "Incorrect error code returned from Speed calculation lib:");

        _LIT(KCodes, "Lat1= %f, Long1= %f, Lat2= %f, Long2= %f, Returned = %d, Expected = %d, row= %d");

        buf.Format(KCodes, source.Latitude(), 

                           source.Longitude(), 

                           target.Latitude(), 

                           target.Longitude(), 

                           aCalc.ReturnedErrorCode(), 

                           aCalc.SpeedErrorCode(), aRow);

        ERR_PRINTF1(KIncorrectErrorCode);

        }

    ERR_PRINTF1(buf);

    }

//  End of File