diff -r 7f293ed715ec -r a4835904093b LbsApi/src/calculationmethodsstep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/LbsApi/src/calculationmethodsstep.cpp Wed Jul 28 13:24:28 2010 +0100 @@ -0,0 +1,480 @@ +// Copyright (c) 2005-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 CalculationMethodsStep.cpp + @internalTechnology +*/ +#include "calculationmethodsstep.h" +#include "te_lbsapisuitedefs.h" + +#include "lcfsbucommondefinitions.h" + +#include +#include + +CCalculationMethodsStep::~CCalculationMethodsStep() +/** + * Destructor + */ + { + } + +CCalculationMethodsStep::CCalculationMethodsStep() +/** + * Constructor + */ + { + // **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(KCalculationMethodsStep); + } + +TVerdict CCalculationMethodsStep::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + CTe_LbsApiSuiteStepBase::doTestStepPreambleL(); + if (TestStepResult()!=EPass) + return TestStepResult(); + // process some pre setting to this test step then set SetTestStepResult to EFail or Epass. + SetTestStepResult(EPass); + return TestStepResult(); + } + + +TVerdict CCalculationMethodsStep::doTestStepL() +/** + * @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. + */ + { + if (TestStepResult()==EPass) + { + TInt test; + if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test) + ) + { + // Leave if there's any error. + User::Leave(KErrNotFound); + } + SetTestStepResult(EPass); + StartL(test); + } + return TestStepResult(); + } + + + +TVerdict CCalculationMethodsStep::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + // process something post setting to the test step + // uncomment the following line if you have common post setting to all the test steps in there + // CTe_LbsApiVariant2SuiteStepBase::doTestStepPostambleL(); + // uncomment the following line if you have post process or remove the following line if no post process + // SetTestStepResult(EPass); // or EFail + return TestStepResult(); + } + + +void CCalculationMethodsStep::StartL(TInt aIndex) + { + switch(aIndex) + { + case 0: + Calculation_InvalidL(); + break; + case 1: + Calculation_BasicsL(); + break; + case 2: + Calculation_TCoordinate_MoveBigL(); + break; + } + } + + +#define REPORT_REAL(_real) \ + report.Format(_L("%15.9f"), _real); \ + LOG_DES(report); + +#define REPORT_REAL_16(_real) \ + report.Format(_L("%22.16f"), _real); \ + LOG_DES(report); + +#define REPORT_REAL_G(_real) \ + report.Format(_L("%10g"), _real); \ + LOG_DES(report); + +#define REPORT_CRLF \ + report.Format(_L("\n")); \ + LOG_DES(report); + +#define REPORT_TAB \ + report.Format(_L("\t")); \ + LOG_DES(report); + +// +// +// TCoordinate +// +// + +void CCalculationMethodsStep::Calculation_BasicsL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + TRealX nan; + nan.SetNaN(); + + const TReal tlat = 10, tlon = 20, acc1 = 5, acc2 = 15; + TReal32 distance, bearing, delta, speed; + + TCoordinate sCoord, tCoord, zero(0,0), target(tlat, tlon); + TLocality sLoc, tLoc; + TPosition sPos, tPos; + + // + // 1. TCoordinate + + sCoord.SetCoordinate(0, 0); + tCoord.SetCoordinate(tlat, tlon); + + CHECK(sCoord.Distance(tCoord, distance) == KErrNone); + CHECK(sCoord.Distance(sCoord, distance) == KErrNone); + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrNone); + CHECK(sCoord.Move(distance, bearing) == KErrNone); + CHECK(sCoord.Move(distance, bearing) == KErrNone); + + // + // 2. TLocality + + sLoc = TLocality(zero, acc1); + tLoc = TLocality(target, acc2); + + CHECK(sLoc.Distance(tCoord, distance) == KErrNone); + CHECK(sLoc.Distance(sCoord, distance) == KErrNone); + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrNone); + CHECK(sLoc.Distance(sLoc, distance, delta) == KErrNone); + CHECK(sLoc.BearingTo(tCoord, bearing) == KErrNone); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrNone); + + // + // 2. TPosition + + TTime time1, time2; + time1.UniversalTime(); + time2 = time1 + TTimeIntervalMinutes(60); + + sPos = TPosition(sLoc, time1); + tPos = TPosition(tLoc, time2); + + CHECK(sPos.Speed(tPos, speed) == KErrNone); + CHECK(sPos.Speed(TPosition(sLoc, time2), speed) == KErrNone); + CHECK(sPos.Speed(tPos, speed, delta) == KErrNone); + CHECK(sPos.Speed(TPosition(sLoc, time2), speed, delta) == KErrNone); + + StandardCleanup(); + } + +void CCalculationMethodsStep::Calculation_InvalidL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + TRealX nan; + nan.SetNaN(); + + const TReal lat = 10, lon = 20, acc = 5; + const TReal32 dist = 1000, bear = 60; + + const TCoordinate zeroCoord(0, 0), north(90, 0), south(-90, 0); + + enum ENanParam + { + LAT, LON, ACC, + }; + + const TCoordinate nanCoord[] = + { + TCoordinate(nan, lon), + TCoordinate(lat, nan) + }; + + const TLocality nanLoc[] = + { + TLocality(nanCoord[LAT], acc), + TLocality(nanCoord[LON], acc), + TLocality(zeroCoord, nan) + }; + + // + // 1. TCoordinate + + TCoordinate sCoord, tCoord; + TReal32 distance, bearing; + + // NaN in Distance, BearingTo, Move + + tCoord = zeroCoord; + + sCoord = nanCoord[LAT]; + CHECK(sCoord.Distance(tCoord, distance) == KErrArgument); + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument); + CHECK(sCoord.Move(dist, bear) == KErrArgument); + + sCoord = nanCoord[LON]; + CHECK(sCoord.Distance(tCoord, distance) == KErrArgument); + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument); + CHECK(sCoord.Move(dist, bear) == KErrArgument); + + sCoord = zeroCoord; + + tCoord = nanCoord[LAT]; + CHECK(sCoord.Distance(tCoord, distance) == KErrArgument); + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument); + + tCoord = nanCoord[LON]; + CHECK(sCoord.Distance(tCoord, distance) == KErrArgument); + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument); + + // Incalculable cases + + // poles + tCoord = zeroCoord; + + sCoord = north; + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable); + CHECK(sCoord.Move(dist, bear) == KErrPositionIncalculable); + + sCoord = south; + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable); + CHECK(sCoord.Move(dist, bear) == KErrPositionIncalculable); + + // same coords + sCoord = tCoord = zeroCoord; + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable); + + // antipodal + tCoord.SetCoordinate(-zeroCoord.Latitude(), zeroCoord.Longitude() + 180); + CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable); + + // + // 2. TLocality + + TLocality sLoc, tLoc; + TReal32 delta; + + // NaN in Distance and BearingTo + + tLoc = TLocality(zeroCoord, acc); + + sLoc = nanLoc[LAT]; + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument); + + sLoc = nanLoc[LON]; + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument); + + sLoc = nanLoc[ACC]; + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument); + + sLoc = TLocality(zeroCoord, acc); + + tLoc = nanLoc[LAT]; + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument); + + tLoc = nanLoc[LON]; + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument); + + tLoc = nanLoc[ACC]; + CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument); + + // Incalculable cases + + // 1 latitude degree is about 117 km + const TReal32 circle = 200 * 1000; + + // pole in error circle + sLoc = TLocality(TCoordinate(89, 0), circle); + tLoc = TLocality(zeroCoord, 0); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable); + + // overlapping error circles + sLoc = TLocality(TCoordinate(1, 0), circle); + tLoc = TLocality(TCoordinate(-1, 0), circle); + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable); + + // overlapping error circles if target is antipodal + sLoc = TLocality(TCoordinate(1, 0), circle); + tLoc = TLocality(TCoordinate(1, 180), circle); // antipodal is (-1, 0) + CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable); + + // + // 3. TPosition + + TPosition sPos, tPos; + TReal32 speed; + + // Nan in Speed methods + TTime time1, time2; + time1.UniversalTime(); + time2 = time1 + TTimeIntervalMinutes(60); + + tPos = TPosition(TLocality(zeroCoord, acc), time2); + + sPos = TPosition(nanLoc[LAT], time1); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + sPos = TPosition(nanLoc[LON], time1); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + sPos = TPosition(nanLoc[ACC], time1); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + sPos = TPosition(TLocality(zeroCoord, acc), time1); + + tPos = TPosition(nanLoc[LAT], time2); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + tPos = TPosition(nanLoc[LON], time2); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + tPos = TPosition(nanLoc[ACC], time2); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + // Zero time + + sPos = TPosition(TLocality(zeroCoord, acc), 0); + tPos = TPosition(TLocality(zeroCoord, acc), time2); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + sPos = TPosition(TLocality(zeroCoord, acc), time1); + tPos = TPosition(TLocality(zeroCoord, acc), 0); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + // Same time + + sPos = TPosition(TLocality(zeroCoord, acc), time1); + tPos = TPosition(TLocality(zeroCoord, acc), time1); + CHECK(sPos.Speed(tPos, speed) == KErrArgument); + CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument); + + StandardCleanup(); + } + + + + +TReal32 NextReal32Value(TReal32 aReal32) + { + TInt32* pint32 = (TInt32*) &(aReal32); + (*pint32) = (*pint32) + 1; // works ok only if increment does not touch exponent!!! + return *((TReal32*) pint32); + } + +TReal32 PrevReal32Value(TReal32 aReal32) + { + TInt32* pint32 = (TInt32*) &(aReal32); + (*pint32) = (*pint32) - 1; // works ok only if decrement does not touch exponent!!! + return *((TReal32*) pint32); + } + +void CCalculationMethodsStep::Calculation_TCoordinate_MoveBigL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + TBuf<256> report; + const TReal32 KEarthRadius = 6371010; + const TReal32 KAccuracy = 0.1; + + TInt bearing; + TReal32 alpha, arc = 2*KPi*KEarthRadius; + TCoordinate center(0,0), farPoint, closePoint, diff; + + _LIT(KHeader, "=== TCoordinate::Move() test for big distances ===\n"); + INFO_PRINTF1(KHeader); + + for (int lon = -180; lon < 180; lon += 60) + { + center = TCoordinate(0, lon); + + report.Format(_L("Center = (%f,%f), Arc(m) = %g(%g)\n"), + center.Latitude(), center.Longitude(), arc, NextReal32Value(arc)); + + for (bearing = 0; bearing < 360; bearing +=60) + { + for (alpha = 0; alpha < 180; alpha += 30) + { + farPoint = closePoint = center; + + TReal32 smallDistance = alpha * KDegToRad * KEarthRadius; + closePoint.Move(bearing, smallDistance); + + TReal bigDistance = ((2*KPi) - alpha*KDegToRad) * KEarthRadius; + farPoint.Move(bearing + 180, bigDistance); + + diff = TCoordinate(closePoint.Latitude() - farPoint.Latitude(), + closePoint.Longitude() - farPoint.Longitude()); + + if ((Abs(diff.Latitude()) > KAccuracy) || + (Abs(diff.Longitude()) > KAccuracy)) + { + report.Format(_L("Alpha %g\n"), alpha); + LOG_DES(report); + + _LIT(KBearingDistance, "\tBearing %3d, Dist(m) %g: (%f;%f)\n"); + report.Format(KBearingDistance, bearing, smallDistance, closePoint.Latitude(), closePoint.Longitude()); + LOG_DES(report); + + report.Format(KBearingDistance, bearing + 180, bigDistance, farPoint.Latitude(), farPoint.Longitude()); + LOG_DES(report); + + report.Format(_L("\tDiff (%f;%f)\n"), diff.Latitude(), diff.Longitude()); + LOG_DES(report); + } + } + } + } + + _LIT(KFooter, "=== TCoordinate::Move() test done ===\n"); + INFO_PRINTF1(KFooter); + + StandardCleanup(); + }