// 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 <lbs.h>
#include <lbssatellite.h>
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();
}