File indexing completed on 2022-10-04 14:00:23

0001 // SPDX-License-Identifier: LGPL-2.1-or-later
0002 
0003 // SPDX-FileCopyrightText: 2010 Matias Kallio <matias.kallio@gmail.com>
0004 // SPDX-FileCopyrightText: 2011 Friedrich W. H. Kossebau <kossebau@kde.org>
0005 // SPDX-FileCopyrightText: 2012 Bernhard Beschow <bbeschow@cs.tu-berlin.de>
0006 
0007 #include "MarbleGlobal.h"
0008 #include "MarbleWidget.h"
0009 #include "GeoDataCoordinates.h"
0010 #include "TestUtils.h"
0011 
0012 #include <QLocale>
0013 #include <QDebug>
0014 #include <QTranslator>
0015 #include <QTemporaryFile>
0016 
0017 using namespace Marble;
0018 
0019 
0020 class TestGeoDataCoordinates : public QObject
0021 {
0022     Q_OBJECT
0023 
0024 private Q_SLOTS:
0025     void initTestCase();
0026 
0027     void testConstruction();
0028     void testSet_Degree();
0029     void testSet_Radian();
0030     void testSetLongitude_Degree();
0031     void testSetLongitude_Radian();
0032     void testSetLatitude_Degree();
0033     void testSetLatitude_Radian();
0034     void testAltitude();
0035     void testOperatorAssignment();
0036     void testDetail();
0037     void testIsPole_data();
0038     void testIsPole();
0039     void testNotation();
0040     void testNormalizeLat_data();
0041     void testNormalizeLat();
0042     void testNormalizeLon_data();
0043     void testNormalizeLon();
0044     void testNormalizeDegree_data();
0045     void testNormalizeDegree();
0046     void testNormalizeRadian_data();
0047     void testNormalizeRadian();
0048     void testFromStringDMS_data();
0049     void testFromStringDMS();
0050     void testFromStringDM_data();
0051     void testFromStringDM();
0052     void testFromStringD_data();
0053     void testFromStringD();
0054     void testFromLocaleString_data();
0055     void testFromLocaleString();
0056     void testToString_Decimal_data();
0057     void testToString_Decimal();
0058     void testToString_DMS_data();
0059     void testToString_DMS();
0060     void testToString_DM_data();
0061     void testToString_DM();
0062     void testPack_data();
0063     void testPack();
0064     void testUTM_data();
0065     void testUTM();
0066 };
0067 
0068 void TestGeoDataCoordinates::initTestCase()
0069 {
0070     QLocale::setDefault( QLocale::c() ); // needed for testing toString* conversions
0071 
0072     QTime time = QTime::currentTime();
0073     qsrand((uint)time.msec());
0074 }
0075 
0076 /*
0077  * test constructors
0078  */
0079 void TestGeoDataCoordinates::testConstruction()
0080 {
0081     GeoDataCoordinates invalid1;
0082 
0083     QVERIFY(!invalid1.isValid());
0084 
0085     GeoDataCoordinates invalid2(invalid1);
0086 
0087     QVERIFY(!invalid2.isValid());
0088     QVERIFY(!invalid1.isValid());
0089     QCOMPARE(invalid1, invalid2);
0090 
0091     const qreal lon = 164.77;
0092     const qreal lat = 55.9;
0093     const qreal alt = 400.003;
0094 
0095     GeoDataCoordinates coordinates3(lon, lat, alt, GeoDataCoordinates::Degree);
0096 
0097     QVERIFY(coordinates3.isValid());
0098     QCOMPARE(coordinates3, GeoDataCoordinates(lon, lat, alt, GeoDataCoordinates::Degree));
0099     QVERIFY(coordinates3 != invalid1);
0100     QVERIFY(coordinates3 != invalid2);
0101 
0102     QCOMPARE(coordinates3.longitude(GeoDataCoordinates::Degree), lon);
0103     QCOMPARE(coordinates3.longitude(), lon*DEG2RAD);
0104 
0105     QCOMPARE(coordinates3.latitude(GeoDataCoordinates::Degree), lat);
0106     QCOMPARE(coordinates3.latitude(), lat*DEG2RAD);
0107 
0108     QCOMPARE(coordinates3.altitude(), alt);
0109 
0110     qreal myLongitude = 0;
0111     qreal myLatitude = 0;
0112 
0113     coordinates3.geoCoordinates(myLongitude, myLatitude, GeoDataCoordinates::Degree);
0114 
0115     QCOMPARE(myLongitude, lon);
0116     QCOMPARE(myLatitude, lat);
0117 
0118     myLongitude = 0;
0119     myLatitude = 0;
0120 
0121     coordinates3.geoCoordinates(myLongitude, myLatitude);
0122 
0123     QCOMPARE(myLongitude, lon*DEG2RAD);
0124     QCOMPARE(myLatitude, lat*DEG2RAD);
0125 
0126     GeoDataCoordinates coordinates4(lon*DEG2RAD, lat*DEG2RAD, alt);
0127 
0128     QVERIFY(coordinates4.isValid());
0129     QCOMPARE(coordinates4, GeoDataCoordinates(lon, lat, alt, GeoDataCoordinates::Degree));
0130     QCOMPARE(coordinates4, coordinates3);
0131     QVERIFY(coordinates4 != invalid1);
0132     QVERIFY(coordinates4 != invalid2);
0133 
0134     GeoDataCoordinates coordinates5(coordinates3);
0135 
0136     QVERIFY(coordinates5.isValid());
0137     QCOMPARE(coordinates5, GeoDataCoordinates(lon, lat, alt, GeoDataCoordinates::Degree));
0138     QCOMPARE(coordinates5, coordinates3);
0139     QCOMPARE(coordinates5, coordinates4);
0140     QVERIFY(coordinates5 != invalid1);
0141     QVERIFY(coordinates5 != invalid2);
0142 
0143     GeoDataCoordinates coordinates6(invalid1.longitude(), invalid1.latitude(), invalid1.altitude(), GeoDataCoordinates::Radian, invalid1.detail());
0144 
0145     QVERIFY(coordinates6.isValid());  // it should be valid, even though
0146     QCOMPARE(coordinates6, invalid1); // it is equal to an invalid one
0147 }
0148 
0149 /*
0150  * test setting coordinates in degree
0151  */
0152 void TestGeoDataCoordinates::testSet_Degree()
0153 {
0154     const qreal lon = 345.8;
0155     const qreal lat = 70.3;
0156     const qreal alt = 1000.9;
0157 
0158     GeoDataCoordinates coordinates1; // invalid
0159     coordinates1.set(lon, lat, alt, GeoDataCoordinates::Degree);
0160 
0161     QVERIFY(coordinates1.isValid());
0162 
0163     GeoDataCoordinates coordinates2(coordinates1);
0164     coordinates2.set(0, 0, 0, GeoDataCoordinates::Degree);
0165 
0166     QVERIFY(coordinates2.isValid());
0167     QCOMPARE(coordinates1, GeoDataCoordinates(lon, lat, alt, GeoDataCoordinates::Degree));
0168     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0, 0, GeoDataCoordinates::Degree));
0169 
0170 }
0171 
0172 /*
0173  * test setting coordinates in radian
0174  */
0175 void TestGeoDataCoordinates::testSet_Radian()
0176 {
0177     const qreal lon = 1.3;
0178     const qreal lat = 0.7;
0179     const qreal alt = 6886.44;
0180 
0181     GeoDataCoordinates coordinates1; // invalid
0182     coordinates1.set(lon, lat, alt);
0183 
0184     QVERIFY(coordinates1.isValid());
0185 
0186     GeoDataCoordinates coordinates2(coordinates1);
0187     coordinates2.set(0, 0, 0);
0188 
0189     QVERIFY(coordinates2.isValid());
0190     QCOMPARE(coordinates1, GeoDataCoordinates(lon, lat, alt));
0191     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0, 0));
0192 }
0193 
0194 /*
0195  * test setLongitude() in degree
0196  */
0197 void TestGeoDataCoordinates::testSetLongitude_Degree()
0198 {
0199     const qreal lon = 143.8;
0200 
0201     GeoDataCoordinates coordinates1; // invalid
0202     coordinates1.setLongitude(lon, GeoDataCoordinates::Degree);
0203 
0204     QVERIFY(coordinates1.isValid());
0205 
0206     GeoDataCoordinates coordinates2(coordinates1);
0207     coordinates2.setLongitude(0, GeoDataCoordinates::Degree);
0208 
0209     QVERIFY(coordinates2.isValid());
0210     QCOMPARE(coordinates1, GeoDataCoordinates(lon, 0, 0, GeoDataCoordinates::Degree));
0211     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0, 0, GeoDataCoordinates::Degree));
0212 }
0213 
0214 /*
0215  * test setLongitude() in radian
0216  */
0217 void TestGeoDataCoordinates::testSetLongitude_Radian()
0218 {
0219     const qreal lon = 2.5;
0220 
0221     GeoDataCoordinates coordinates1; // invalid
0222     coordinates1.setLongitude(lon);
0223 
0224     QVERIFY(coordinates1.isValid());
0225 
0226     GeoDataCoordinates coordinates2(coordinates1);
0227     coordinates2.setLongitude(0);
0228 
0229     QVERIFY(coordinates2.isValid());
0230     QCOMPARE(coordinates1, GeoDataCoordinates(lon, 0));
0231     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0));
0232 }
0233 
0234 /*
0235  * test setLatitude() and latitude() in degree
0236  */
0237 void TestGeoDataCoordinates::testSetLatitude_Degree()
0238 {
0239     const qreal lat = 75.0;
0240 
0241     GeoDataCoordinates coordinates1; // invalid
0242     coordinates1.setLatitude(lat, GeoDataCoordinates::Degree);
0243 
0244     QVERIFY(coordinates1.isValid());
0245 
0246     GeoDataCoordinates coordinates2(coordinates1);
0247     coordinates2.setLatitude(0, GeoDataCoordinates::Degree);
0248 
0249     QVERIFY(coordinates2.isValid());
0250     QCOMPARE(coordinates1, GeoDataCoordinates(0, lat, 0, GeoDataCoordinates::Degree));
0251     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0, 0, GeoDataCoordinates::Degree));
0252 }
0253 
0254 /*
0255  * test setLatitude() in radian
0256  */
0257 void TestGeoDataCoordinates::testSetLatitude_Radian()
0258 {
0259     const qreal lat = 1.2;
0260 
0261     GeoDataCoordinates coordinates1; // invalid
0262     coordinates1.setLatitude(lat);
0263 
0264     QVERIFY(coordinates1.isValid());
0265 
0266     GeoDataCoordinates coordinates2(coordinates1);
0267     coordinates2.setLatitude(0);
0268 
0269     QVERIFY(coordinates2.isValid());
0270     QCOMPARE(coordinates1, GeoDataCoordinates(0, lat));
0271     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0));
0272 }
0273 
0274 /*
0275  * test setAltitude()
0276  */
0277 void TestGeoDataCoordinates::testAltitude()
0278 {
0279     const qreal alt = 400;
0280 
0281     GeoDataCoordinates coordinates1; // invalid
0282     coordinates1.setAltitude(alt);
0283 
0284     QVERIFY(coordinates1.isValid());
0285 
0286     GeoDataCoordinates coordinates2(coordinates1);
0287     coordinates2.setAltitude(0);
0288 
0289     QVERIFY(coordinates2.isValid());
0290     QCOMPARE(coordinates1, GeoDataCoordinates(0, 0, alt));
0291     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0, 0));
0292 }
0293 
0294 void TestGeoDataCoordinates::testOperatorAssignment()
0295 {
0296     const qreal lon = 123.4;
0297     const qreal lat = 56.7;
0298     const qreal alt = 890.1;
0299 
0300     const GeoDataCoordinates coordinates1(lon, lat, alt, GeoDataCoordinates::Degree);
0301     const GeoDataCoordinates coordinates2(0, 0, 0);
0302 
0303     GeoDataCoordinates coordinates3; // invalid
0304     coordinates3 = coordinates1;
0305 
0306     QVERIFY(coordinates3.isValid());
0307     QCOMPARE(coordinates1, GeoDataCoordinates(lon, lat, alt, GeoDataCoordinates::Degree)); // stays unmodified
0308     QCOMPARE(coordinates3, coordinates1);
0309 
0310     coordinates3 = GeoDataCoordinates();
0311 
0312     QVERIFY(!coordinates3.isValid());
0313 
0314     GeoDataCoordinates coordinates4(coordinates1);
0315     coordinates4 = coordinates2;
0316 
0317     QVERIFY(coordinates4.isValid());
0318     QCOMPARE(coordinates1, GeoDataCoordinates(lon, lat, alt, GeoDataCoordinates::Degree)); // stays unmodified
0319     QCOMPARE(coordinates2, GeoDataCoordinates(0, 0, 0)); // stays unmodified
0320     QCOMPARE(coordinates4, coordinates2);
0321 }
0322 
0323 /*
0324  * test setDetail() and detail()
0325  */
0326 void TestGeoDataCoordinates::testDetail()
0327 {
0328     const quint8 detailnumber = 15;
0329 
0330     GeoDataCoordinates coordinates1;
0331     coordinates1.setDetail(detailnumber);
0332 
0333     GeoDataCoordinates coordinates2(coordinates1);
0334     coordinates2.setDetail(0);
0335 
0336     QCOMPARE(coordinates1.detail(), detailnumber);
0337 }
0338 
0339 /*
0340  * test setDefaultNotation() and defaultNotation
0341  */
0342 void TestGeoDataCoordinates::testNotation()
0343 {
0344     GeoDataCoordinates::setDefaultNotation(GeoDataCoordinates::Decimal);
0345     QVERIFY(GeoDataCoordinates::defaultNotation() == GeoDataCoordinates::Decimal);
0346 
0347     GeoDataCoordinates::setDefaultNotation(GeoDataCoordinates::DMS);
0348     QVERIFY(GeoDataCoordinates::defaultNotation() == GeoDataCoordinates::DMS);
0349 }
0350 
0351 /*
0352  * test data for testIsPole()
0353  */
0354 void TestGeoDataCoordinates::testIsPole_data()
0355 {
0356     QTest::addColumn<qreal>("lon");
0357     QTest::addColumn<qreal>("lat");
0358     QTest::addColumn<qreal>("alt");
0359     QTest::addColumn<QString>("pole");
0360 
0361     QTest::newRow("false") << qreal(50.0) << qreal(50.0) << qreal(0.0) << "false_pole";
0362     QTest::newRow("south") << qreal(0.0) << qreal(-90.0) << qreal(0.0) << "south_pole";
0363     QTest::newRow("north") << qreal(0.0) << qreal(90.0) << qreal(0.0) << "north_pole";
0364 }
0365 
0366 /*
0367  * Test isPole-method
0368  */
0369 void TestGeoDataCoordinates::testIsPole()
0370 {
0371     QFETCH(qreal, lon);
0372     QFETCH(qreal, lat);
0373     QFETCH(qreal, alt);
0374     QFETCH(QString, pole);
0375 
0376     GeoDataCoordinates coordinates1;
0377 
0378     if (pole == QLatin1String("false_pole")) {
0379         coordinates1.set(lon, lat, alt, GeoDataCoordinates::Degree);
0380         QVERIFY(coordinates1.isPole() == false);
0381     } else if (pole == QLatin1String("south_pole")) {
0382         coordinates1.set(lon, lat, alt, GeoDataCoordinates::Degree);
0383         QVERIFY(coordinates1.isPole(SouthPole));
0384     } else if (pole == QLatin1String("north_pole")) {
0385         coordinates1.set(lon, lat, alt, GeoDataCoordinates::Degree);
0386         QVERIFY(coordinates1.isPole(NorthPole));
0387     }
0388 }
0389 
0390 void TestGeoDataCoordinates::testNormalizeLat_data()
0391 {
0392     QTest::addColumn<qreal>( "latRadian" );
0393 
0394     QTest::newRow( "north pole" ) << qreal(M_PI / 2);
0395     QTest::newRow( "south pole" ) << qreal(- M_PI / 2);
0396     QTest::newRow( "somewhere" ) << qreal(1.0);
0397 }
0398 
0399 void TestGeoDataCoordinates::testNormalizeLat()
0400 {
0401     QFETCH( qreal, latRadian );
0402 
0403     qreal latDegree = RAD2DEG * latRadian;
0404     for ( int i = 1; i < 10; ++i ) {
0405         if ( ( i % 2 ) == 0 ) {
0406             QCOMPARE( GeoDataCoordinates::normalizeLat( latRadian + i * M_PI, GeoDataCoordinates::Radian ), latRadian );
0407             QCOMPARE( GeoDataCoordinates::normalizeLat( latRadian + i * M_PI ), latRadian );
0408             QCOMPARE( GeoDataCoordinates::normalizeLat( latDegree + i * 180, GeoDataCoordinates::Degree ), latDegree );
0409         }
0410         else {
0411             QCOMPARE( GeoDataCoordinates::normalizeLat( latRadian + i * M_PI, GeoDataCoordinates::Radian ), -latRadian );
0412             QCOMPARE( GeoDataCoordinates::normalizeLat( latRadian + i * M_PI ), -latRadian );
0413             QCOMPARE( GeoDataCoordinates::normalizeLat( latDegree + i * 180, GeoDataCoordinates::Degree ), -latDegree );
0414         }
0415     }
0416 }
0417 
0418 void TestGeoDataCoordinates::testNormalizeLon_data()
0419 {
0420     QTest::addColumn<qreal>( "lonRadian" );
0421 
0422     QTest::newRow( "half east" ) << qreal(M_PI / 2);
0423     QTest::newRow( "half west" ) << qreal(- M_PI / 2);
0424     QTest::newRow( "somewhere" ) << qreal(1.0);
0425     QTest::newRow( "date line east" ) << qreal(M_PI);
0426     QTest::newRow( "date line west" ) << - qreal(M_PI);
0427 
0428 }
0429 
0430 void TestGeoDataCoordinates::testNormalizeLon()
0431 {
0432     QFETCH( qreal, lonRadian );
0433 
0434     qreal lonDegree = RAD2DEG * lonRadian;
0435     for ( int i = 1; i < 10; ++i ) {
0436         if ( lonRadian == qreal(M_PI) || lonRadian == qreal(-M_PI) ) {
0437             int lonRadianLarge = qRound( lonRadian * 1000 );
0438             int lonDegreeLarge = qRound( lonDegree * 1000 );
0439             if ( qRound( GeoDataCoordinates::normalizeLon( lonRadian + i * 2 * M_PI ) * 1000 ) != lonRadianLarge
0440                  && qRound( GeoDataCoordinates::normalizeLon( lonRadian + i * 2 * M_PI ) * 1000 ) != -lonRadianLarge )
0441             {
0442                 QFAIL( "Error at M_PI/-M_PI" );
0443             }
0444             if ( qRound( GeoDataCoordinates::normalizeLon( lonRadian + i * 2 * M_PI, GeoDataCoordinates::Radian ) * 1000 ) != lonRadianLarge
0445                  && qRound( GeoDataCoordinates::normalizeLon( lonRadian + i * 2 * M_PI, GeoDataCoordinates::Radian ) * 1000 ) != -lonRadianLarge )
0446             {
0447                 QFAIL( "Error at M_PI/-M_PI" );
0448             }
0449             if ( qRound( GeoDataCoordinates::normalizeLon( lonDegree + i * 360, GeoDataCoordinates::Degree ) * 1000 ) != lonDegreeLarge
0450                  && qRound( GeoDataCoordinates::normalizeLon( lonDegree + i * 360, GeoDataCoordinates::Degree ) * 1000 ) != -lonDegreeLarge )
0451             {
0452                 QFAIL( "Error at M_PI/-M_PI" );
0453             }
0454         }
0455         else {
0456             QCOMPARE( GeoDataCoordinates::normalizeLon( lonRadian + i * 2 * M_PI, GeoDataCoordinates::Radian ), lonRadian );
0457             QCOMPARE( GeoDataCoordinates::normalizeLon( lonRadian + i * 2 * M_PI ), lonRadian );
0458             QCOMPARE( GeoDataCoordinates::normalizeLon( lonDegree + i * 360, GeoDataCoordinates::Degree ), lonDegree );
0459         }
0460     }
0461 }
0462 
0463 /*
0464  * test data for testNormalize()
0465  */
0466 void TestGeoDataCoordinates::testNormalizeDegree_data()
0467 {
0468     QTest::addColumn<qreal>("lon");
0469     QTest::addColumn<qreal>("lat");
0470 
0471     QTest::newRow("deg") << qreal(200.0) << qreal(130.0);
0472 }
0473 
0474 /*
0475  * test normalizeLon(), normalizeLat() and normalizeLonLat()
0476  */
0477 void TestGeoDataCoordinates::testNormalizeDegree()
0478 {
0479     QFETCH(qreal, lon);
0480     QFETCH(qreal, lat);
0481 
0482     QCOMPARE(GeoDataCoordinates::normalizeLon(lon, GeoDataCoordinates::Degree), qreal(-160));
0483     QCOMPARE(GeoDataCoordinates::normalizeLat(lat, GeoDataCoordinates::Degree), qreal(50));
0484 
0485     qreal normalized_lon = lon;
0486     qreal normalized_lat = lat;
0487 
0488     GeoDataCoordinates::normalizeLonLat( normalized_lon, normalized_lat, GeoDataCoordinates::Degree);
0489     QCOMPARE(normalized_lon, qreal(20));
0490     QCOMPARE(normalized_lat, qreal(50));
0491 }
0492 
0493 /*
0494  * test data for testNormalize()
0495  */
0496 void TestGeoDataCoordinates::testNormalizeRadian_data()
0497 {
0498     QTest::addColumn<qreal>("lon");
0499     QTest::addColumn<qreal>("lat");
0500 
0501     QTest::newRow("rad") << qreal(3.6) << qreal(2.7);
0502 }
0503 
0504 /*
0505  * test normalizeLon(), normalizeLat() and normalizeLonLat()
0506  */
0507 void TestGeoDataCoordinates::testNormalizeRadian()
0508 {
0509     QFETCH(qreal, lon);
0510     QFETCH(qreal, lat);
0511 
0512     // Compare up to three decimals
0513     qreal value = GeoDataCoordinates::normalizeLon(lon, GeoDataCoordinates::Radian);
0514     QCOMPARE(ceil(value * 1000) / 1000, qreal(-2.683));
0515 
0516     value = GeoDataCoordinates::normalizeLat(lat, GeoDataCoordinates::Radian);
0517     QCOMPARE(ceil(value * 1000) / 1000, qreal(0.442));
0518 
0519     qreal normalized_lon = lon;
0520     qreal normalized_lat = lat;
0521 
0522     GeoDataCoordinates::normalizeLonLat( normalized_lon, normalized_lat, GeoDataCoordinates::Radian);
0523     QCOMPARE(ceil(normalized_lon * 1000) / 1000, qreal(0.459));
0524     QCOMPARE(ceil(normalized_lat * 1000) / 1000, qreal(0.442));
0525 }
0526 
0527 enum SignType {NoSign, PositiveSign, NegativeSign};
0528 enum SphereType {PosSphere, NegSphere};
0529 enum UnitsType {NoUnits, WithUnits};
0530 enum SpacesType {NoSpaces, WithSpaces};
0531 enum LocaleType {CLocale, SystemLocale};
0532 
0533 static QString
0534 createDegreeString(SignType signType,
0535                    int degreeValue, int minutesValue, qreal secondsValue,
0536                    LocaleType locale,
0537                    UnitsType unitsType, SpacesType spacesType)
0538 {
0539     QString string;
0540 
0541     // add degree
0542     if (signType != NoSign) string.append(QLatin1Char(signType==PositiveSign?'+':'-'));
0543     string.append(QString::number(degreeValue));
0544     if (unitsType == WithUnits) string.append(QChar(0xb0));
0545 
0546     // add minutes
0547     string.append(QLatin1Char(' ') + QString::number(minutesValue));
0548     if (unitsType == WithUnits) string.append(QLatin1Char('\''));
0549 
0550     // add seconds
0551     if (locale == CLocale) {
0552         string.append(QLatin1Char(' ') + QString::number(secondsValue, 'f', 10));
0553     } else {
0554         string.append(QLatin1Char(' ') + QLocale::system().toString(secondsValue, 'f', 10));
0555     }
0556     if (unitsType == WithUnits) string.append(QLatin1Char('"'));
0557 
0558     if (spacesType == WithSpaces) string.append(QLatin1Char(' '));
0559 
0560     return string;
0561 }
0562 
0563 static QString
0564 createDegreeString(SignType signType,
0565                    int degreeValue, qreal minutesValue,
0566                    LocaleType locale,
0567                    UnitsType unitsType, SpacesType spacesType)
0568 {
0569     QString string;
0570 
0571     // add degree
0572     if (signType != NoSign) string.append(QLatin1Char(signType==PositiveSign?'+':'-'));
0573     string.append(QString::number(degreeValue));
0574     if (unitsType == WithUnits) string.append(QChar(0xb0));
0575 
0576     // add minutes
0577     if (locale == CLocale) {
0578         string.append(QLatin1Char(' ') + QString::number(minutesValue, 'f', 10));
0579     } else {
0580         string.append(QLatin1Char(' ') + QLocale::system().toString(minutesValue, 'f', 10));
0581     }
0582     if (unitsType == WithUnits) string.append(QLatin1Char('\''));
0583 
0584     if (spacesType == WithSpaces) string.append(QLatin1Char(' '));
0585 
0586     return string;
0587 }
0588 
0589 static QString
0590 createDegreeString(SignType signType,
0591                    qreal degreeValue,
0592                    LocaleType locale,
0593                    UnitsType unitsType, SpacesType spacesType)
0594 {
0595     QString string;
0596 
0597     // add degree
0598     if (signType != NoSign) string.append(QLatin1Char(signType==PositiveSign?'+':'-'));
0599     if (locale == CLocale) {
0600         string.append(QString::number(degreeValue, 'f', 10));
0601     } else {
0602         string.append(QLocale::system().toString(degreeValue, 'f', 10));
0603     }
0604     if (unitsType == WithUnits) string.append(QChar(0xb0));
0605 
0606     if (spacesType == WithSpaces) string.append(QLatin1Char(' '));
0607 
0608     return string;
0609 }
0610 
0611 /*
0612  * test data for testStringDMS()
0613  */
0614 void TestGeoDataCoordinates::testFromStringDMS_data()
0615 {
0616     QTest::addColumn<QString>("string");
0617     QTest::addColumn<qreal>("lon");
0618     QTest::addColumn<qreal>("lat");
0619 
0620     const QVector<SignType> signTypes = QVector<SignType>()
0621         << NoSign << PositiveSign << NegativeSign;
0622     const QVector<SphereType> sphereTypes = QVector<SphereType>()
0623         << PosSphere << NegSphere;
0624     const QVector<UnitsType> unitsTypes = QVector<UnitsType>()
0625         << NoUnits << WithUnits;
0626     const QVector<SpacesType> spacesTypes = QVector<SpacesType>()
0627         << NoSpaces << WithSpaces;
0628     const QVector<LocaleType> localeTypes = QVector<LocaleType>()
0629         << CLocale << SystemLocale;
0630 
0631     const QVector<uint> degreeSamples = QVector<uint>()
0632         << 0 << 140 << 180;
0633     const QVector<uint> minutesSamples = QVector<uint>()
0634         << 0 << 23 << 59;
0635     const QVector<qreal> secondsSamples = QVector<qreal>()
0636         << 0.0 << 3.14159 << 59.9999999;
0637 
0638     foreach(const UnitsType unitsType, unitsTypes) {
0639     foreach(const SpacesType spacesType, spacesTypes) {
0640     // lon
0641     foreach(const SphereType lonSphere, sphereTypes) {
0642     foreach(const SignType lonSignType, signTypes) {
0643         const bool lonIsPositive =
0644             (lonSphere==PosSphere && lonSignType!=NegativeSign) ||
0645             (lonSphere==NegSphere && lonSignType==NegativeSign);
0646     foreach(const uint lonDegree, degreeSamples) {
0647     foreach(const uint lonMinutes, minutesSamples) {
0648         if(lonDegree == 180 && lonMinutes != 0) continue;
0649     foreach(const qreal lonSeconds, secondsSamples) {
0650         if(lonDegree == 180 && lonSeconds != 0.0) continue;
0651     // lat
0652     foreach(const SphereType latSphere, sphereTypes) {
0653     foreach(const SignType latSignType, signTypes) {
0654         const bool latIsPositive =
0655             (latSphere==PosSphere && latSignType!=NegativeSign) ||
0656             (latSphere==NegSphere && latSignType==NegativeSign);
0657     foreach(const uint latDegree, degreeSamples) {
0658     foreach(const uint latMinutes, minutesSamples) {
0659         if(latDegree == 180 && latMinutes != 0) continue;
0660     foreach(const qreal latSeconds, secondsSamples) {
0661         if(latDegree == 180 && latSeconds != 0.0) continue;
0662     // locale
0663     foreach(const LocaleType locale, localeTypes) {
0664 
0665     // actual construction
0666         // Create lon & lat values
0667         qreal lon = (qreal)lonDegree + lonMinutes*MIN2HOUR + lonSeconds*SEC2HOUR;
0668         if( ! lonIsPositive )
0669             lon *= -1;
0670         qreal lat = (qreal)latDegree + latMinutes*MIN2HOUR + latSeconds*SEC2HOUR;
0671         if( ! latIsPositive )
0672             lat *= -1;
0673 
0674         // Create string
0675         QString string;
0676         string.append(createDegreeString(latSignType,
0677                                          latDegree, latMinutes, latSeconds,
0678                                          locale,
0679                                          unitsType, spacesType));
0680         string.append(QLatin1Char(latSphere==PosSphere?'N':'S'));
0681         string.append(QLatin1Char(' '));
0682         string.append(createDegreeString(lonSignType,
0683                                          lonDegree, lonMinutes, lonSeconds,
0684                                          locale,
0685                                          unitsType, spacesType));
0686         string.append(QLatin1Char(lonSphere==PosSphere?'E':'W'));
0687 
0688         // Create row title
0689         QString rowTitle;
0690         rowTitle.append(QLatin1String(spacesType==WithSpaces?"spaced dir":"unspaced dir"))
0691                 .append(QLatin1String(unitsType==WithUnits?"|units":"|no units"))
0692                 .append(QLatin1String("|lon:"))
0693                 .append(QLatin1Char(lonIsPositive?'+':'-'))
0694                 .append(QString::number(lonDegree)+QChar(0xb0))
0695                 .append(QString::number(lonMinutes)+QLatin1Char('\''))
0696                 .append(QString::number(lonSeconds, 'f', 10)+QLatin1Char('"'))
0697                 .append(QLatin1Char(lonSphere==PosSphere?'P':'N'))
0698                 .append(QLatin1String("|lat:"))
0699                 .append(QLatin1Char(latIsPositive?'+':'-'))
0700                 .append(QString::number(latDegree)+QChar(0xb0))
0701                 .append(QString::number(latMinutes)+QLatin1Char('\''))
0702                 .append(QString::number(latSeconds, 'f', 10)+QLatin1Char('"'))
0703                 .append(QLatin1Char(latSphere==PosSphere?'P':'N'))
0704                 .append(QLatin1Char('|')).append(QLatin1Char(locale==CLocale?'C':'L'))
0705                 .append(QLatin1Char('|')).append(string).append(QLatin1Char('|'));
0706         QTest::newRow(rowTitle.toLatin1().constData())
0707             << string
0708             << lon
0709             << lat;
0710     }
0711     }
0712     }
0713     }
0714     }
0715     }
0716     }
0717     }
0718     }
0719     }
0720     }
0721     }
0722     }
0723 }
0724 
0725 /*
0726  * test fromString() with DMS notation
0727  */
0728 void TestGeoDataCoordinates::testFromStringDMS()
0729 {
0730     // only run random 5% of all possible permutations
0731     if ((qreal(qrand()) / RAND_MAX) > 0.05) {
0732         QSKIP("Not picked for this run.");
0733     }
0734 
0735     QFETCH(QString, string);
0736     QFETCH(qreal, lon);
0737     QFETCH(qreal, lat);
0738 
0739     bool succeeded = false;
0740     const GeoDataCoordinates coords = GeoDataCoordinates::fromString(string, succeeded);
0741 
0742     if(! succeeded)
0743         qWarning() << "Could not parse"<<string <<"for"<<lon<<lat;
0744 
0745     QVERIFY(succeeded);
0746     QCOMPARE(coords.longitude(GeoDataCoordinates::Degree), lon);
0747     QCOMPARE(coords.latitude(GeoDataCoordinates::Degree),  lat);
0748 }
0749 
0750 /*
0751  * test data for testStringDM()
0752  */
0753 void TestGeoDataCoordinates::testFromStringDM_data()
0754 {
0755     QTest::addColumn<QString>("string");
0756     QTest::addColumn<qreal>("lon");
0757     QTest::addColumn<qreal>("lat");
0758 
0759     const QVector<SignType> signTypes = QVector<SignType>()
0760         << NoSign << PositiveSign << NegativeSign;
0761     const QVector<SphereType> sphereTypes = QVector<SphereType>()
0762         << PosSphere << NegSphere;
0763     const QVector<UnitsType> unitsTypes = QVector<UnitsType>()
0764         << NoUnits << WithUnits;
0765     const QVector<SpacesType> spacesTypes = QVector<SpacesType>()
0766         << NoSpaces << WithSpaces;
0767     const QVector<LocaleType> localeTypes = QVector<LocaleType>()
0768         << CLocale << SystemLocale;
0769 
0770     const QVector<uint> degreeSamples = QVector<uint>()
0771         << 0 << 140 << 180;
0772     const QVector<qreal> minutesSamples = QVector<qreal>()
0773         << 0.0 << 3.14159 << 59.9999999;
0774 
0775     foreach(const UnitsType unitsType, unitsTypes) {
0776     foreach(const SpacesType spacesType, spacesTypes) {
0777     // lon
0778     foreach(const SphereType lonSphere, sphereTypes) {
0779     foreach(const SignType lonSignType, signTypes) {
0780         const bool lonIsPositive =
0781             (lonSphere==PosSphere && lonSignType!=NegativeSign) ||
0782             (lonSphere==NegSphere && lonSignType==NegativeSign);
0783     foreach(const uint lonDegree, degreeSamples) {
0784     foreach(const qreal lonMinutes, minutesSamples) {
0785         if(lonDegree == 180 && lonMinutes != 0.0) continue;
0786     // lat
0787     foreach(const SphereType latSphere, sphereTypes) {
0788     foreach(const SignType latSignType, signTypes) {
0789         const bool latIsPositive =
0790             (latSphere==PosSphere && latSignType!=NegativeSign) ||
0791             (latSphere==NegSphere && latSignType==NegativeSign);
0792     foreach(const uint latDegree, degreeSamples) {
0793     foreach(const qreal latMinutes, minutesSamples) {
0794         if(latDegree == 180 && latMinutes != 0.0) continue;
0795     // locale
0796     foreach(const LocaleType locale, localeTypes) {
0797 
0798     // actual construction
0799         // Create lon & lat values
0800         qreal lon = (qreal)lonDegree + lonMinutes*MIN2HOUR;
0801         if( ! lonIsPositive )
0802             lon *= -1;
0803         qreal lat = (qreal)latDegree + latMinutes*MIN2HOUR;
0804         if( ! latIsPositive )
0805             lat *= -1;
0806 
0807         // Create string
0808         QString string;
0809         string.append(createDegreeString(latSignType,
0810                                          latDegree, latMinutes,
0811                                          locale,
0812                                          unitsType, spacesType));
0813         string.append(QLatin1Char(latSphere==PosSphere?'N':'S'));
0814         string.append(QLatin1Char(' '));
0815         string.append(createDegreeString(lonSignType,
0816                                          lonDegree, lonMinutes,
0817                                          locale,
0818                                          unitsType, spacesType));
0819         string.append(QLatin1Char(lonSphere==PosSphere?'E':'W'));
0820 
0821         // Create row title
0822         QString rowTitle;
0823         rowTitle.append(QLatin1String(spacesType==WithSpaces?"spaced dir":"unspaced dir"))
0824                 .append(QLatin1String(unitsType==WithUnits?"|units":"|no units"))
0825                 .append(QLatin1String("|lon:"))
0826                 .append(QLatin1Char(lonIsPositive?'+':'-'))
0827                 .append(QString::number(lonDegree)+QChar(0xb0))
0828                 .append(QString::number(lonMinutes, 'f', 10)+QLatin1Char('\''))
0829                 .append(QLatin1Char(lonSphere==PosSphere?'P':'N'))
0830                 .append(QLatin1String("|lat:"))
0831                 .append(QLatin1Char(latIsPositive?'+':'-'))
0832                 .append(QString::number(latDegree)+QChar(0xb0))
0833                 .append(QString::number(latMinutes, 'f', 10)+QLatin1Char('\''))
0834                 .append(QLatin1Char(latSphere==PosSphere?'P':'N'))
0835                 .append(QLatin1Char('|')).append(QLatin1Char(locale==CLocale?'C':'L'))
0836                 .append(QLatin1Char('|')).append(string).append(QLatin1Char('|'));
0837         QTest::newRow(rowTitle.toLatin1().constData())
0838             << string
0839             << lon
0840             << lat;
0841     }
0842     }
0843     }
0844     }
0845     }
0846     }
0847     }
0848     }
0849     }
0850     }
0851     }
0852 }
0853 
0854 /*
0855  * test fromString() with DM notation
0856  */
0857 void TestGeoDataCoordinates::testFromStringDM()
0858 {
0859     // only run random 5% of all possible permutations
0860     if ((qreal(qrand()) / RAND_MAX) > 0.05) {
0861         QSKIP("Not picked for this run.");
0862     }
0863 
0864 
0865     QFETCH(QString, string);
0866     QFETCH(qreal, lon);
0867     QFETCH(qreal, lat);
0868 
0869     bool succeeded = false;
0870     const GeoDataCoordinates coords = GeoDataCoordinates::fromString(string, succeeded);
0871 
0872     if(! succeeded)
0873         qWarning() << "Could not parse"<<string <<"for"<<lon<<lat;
0874 
0875     QVERIFY(succeeded);
0876     QCOMPARE(coords.longitude(GeoDataCoordinates::Degree), lon);
0877     QCOMPARE(coords.latitude(GeoDataCoordinates::Degree),  lat);
0878 }
0879 
0880 /*
0881  * test data for testStringDM()
0882  */
0883 void TestGeoDataCoordinates::testFromStringD_data()
0884 {
0885     QTest::addColumn<QString>("string");
0886     QTest::addColumn<qreal>("lon");
0887     QTest::addColumn<qreal>("lat");
0888 
0889     const QVector<SignType> signTypes = QVector<SignType>()
0890         << NoSign << PositiveSign << NegativeSign;
0891     const QVector<SphereType> sphereTypes = QVector<SphereType>()
0892         << PosSphere << NegSphere;
0893     const QVector<UnitsType> unitsTypes = QVector<UnitsType>()
0894         << NoUnits << WithUnits;
0895     const QVector<SpacesType> spacesTypes = QVector<SpacesType>()
0896         << NoSpaces << WithSpaces;
0897     const QVector<LocaleType> localeTypes = QVector<LocaleType>()
0898         << CLocale << SystemLocale;
0899 
0900     const QVector<qreal> degreeSamples = QVector<qreal>()
0901         << qreal(0.0) << qreal(3.14159) << qreal(180.0);
0902 
0903     foreach(const UnitsType unitsType, unitsTypes) {
0904     foreach(const SpacesType spacesType, spacesTypes) {
0905     // lon
0906     foreach(const SphereType lonSphere, sphereTypes) {
0907     foreach(const SignType lonSignType, signTypes) {
0908         const bool lonIsPositive =
0909             (lonSphere==PosSphere && lonSignType!=NegativeSign) ||
0910             (lonSphere==NegSphere && lonSignType==NegativeSign);
0911     foreach(const qreal lonDegree, degreeSamples) {
0912     // lat
0913     foreach(const SphereType latSphere, sphereTypes) {
0914     foreach(const SignType latSignType, signTypes) {
0915         const bool latIsPositive =
0916             (latSphere==PosSphere && latSignType!=NegativeSign) ||
0917             (latSphere==NegSphere && latSignType==NegativeSign);
0918     foreach(const qreal latDegree, degreeSamples) {
0919     // locale
0920     foreach(const LocaleType locale, localeTypes) {
0921 
0922     // actual construction
0923         // Create lon & lat values
0924         qreal lon = lonDegree;
0925         if (! lonIsPositive)
0926             lon *= -1;
0927         qreal lat = latDegree;
0928         if (! latIsPositive)
0929             lat *= -1;
0930 
0931         // Create string
0932         QString string;
0933         string.append(createDegreeString(latSignType,
0934                                          latDegree,
0935                                          locale,
0936                                          unitsType, spacesType));
0937         string.append(QLatin1Char(latSphere==PosSphere?'N':'S'));
0938         string.append(QLatin1Char(' '));
0939         string.append(createDegreeString(lonSignType,
0940                                          lonDegree,
0941                                          locale,
0942                                          unitsType, spacesType));
0943         string.append(QLatin1Char(lonSphere==PosSphere?'E':'W'));
0944 
0945         // Create row title
0946         QString rowTitle;
0947         rowTitle.append(QLatin1String(spacesType==WithSpaces?"spaced dir":"unspaced dir"))
0948                 .append(QLatin1String(unitsType==WithUnits?"|units":"|no units"))
0949                 .append(QLatin1String("|lon:"))
0950                 .append(QLatin1Char(lonIsPositive?'+':'-'))
0951                 .append(QString::number(lonDegree, 'f', 10)+QChar(0xb0))
0952                 .append(QLatin1Char(lonSphere==PosSphere?'P':'N'))
0953                 .append(QLatin1String("|lat:"))
0954                 .append(QLatin1Char(latIsPositive?'+':'-'))
0955                 .append(QString::number(latDegree, 'f', 10)+QChar(0xb0))
0956                 .append(QLatin1Char(latSphere==PosSphere?'P':'N'))
0957                 .append(QLatin1Char('|')).append(QLatin1Char(locale==CLocale?'C':'L'))
0958                 .append(QLatin1Char('|')).append(string).append(QLatin1Char('|'));
0959         QTest::newRow(rowTitle.toLatin1().constData())
0960             << string
0961             << lon
0962             << lat;
0963     }
0964     }
0965     }
0966     }
0967     }
0968     }
0969     }
0970     }
0971     }
0972 
0973     QTest::newRow("scientific notation") << "0.0,1.0e-2" << qreal(1.0e-2) << qreal(0.0);
0974     QTest::newRow("scientific notation") << "-2.4E0 1.0e-18" << qreal(1e-18) << qreal(-2.4e0);
0975     QTest::newRow("scientific notation") << "1.14e-02;1.33e+01" << qreal(1.33e1) << qreal(1.14e-2);
0976 }
0977 
0978 /*
0979  * test fromString() with DM notation
0980  */
0981 void TestGeoDataCoordinates::testFromStringD()
0982 {
0983     QFETCH(QString, string);
0984     QFETCH(qreal, lon);
0985     QFETCH(qreal, lat);
0986 
0987     bool succeeded = false;
0988     const GeoDataCoordinates coords = GeoDataCoordinates::fromString(string, succeeded);
0989 
0990     if(! succeeded)
0991         qWarning() << "Could not parse"<<string <<"for"<<lon<<lat;
0992 
0993     QVERIFY(succeeded);
0994     QCOMPARE(coords.longitude(GeoDataCoordinates::Degree), lon);
0995     QCOMPARE(coords.latitude(GeoDataCoordinates::Degree),  lat);
0996 }
0997 
0998 class FromStringRegExpTranslator : public QTranslator
0999 {
1000 public:
1001     FromStringRegExpTranslator(const QString& _degree, const QString& _minutes, const QString& _seconds,
1002                                const QString& _north, const QString& _south,
1003                                const QString& _east, const QString& _west)
1004     : QTranslator((QObject*)nullptr)
1005     , degree( _degree )
1006     , minutes( _minutes )
1007     , seconds( _seconds )
1008     , north( _north )
1009     , south( _south )
1010     , east( _east )
1011     , west( _west )
1012     {}
1013 
1014 public: // QTranslator API
1015     bool isEmpty() const override { return false; }
1016     QString translate( const char* context, const char* sourceText,
1017                                const char* disambiguation = nullptr, int n = -1 ) const override;
1018 private:
1019     const QString degree;
1020     const QString minutes;
1021     const QString seconds;
1022     const QString north;
1023     const QString south;
1024     const QString east;
1025     const QString west;
1026 };
1027 
1028 QString FromStringRegExpTranslator::translate(const char* context, const char* sourceText,
1029                                                const char* disambiguation , int n) const
1030 {
1031     Q_UNUSED(n);
1032     if (qstrcmp(context, "GeoDataCoordinates") != 0 )
1033         return QString();
1034 
1035     if (qstrcmp(sourceText, "*") != 0 )
1036         return QString();
1037 
1038     if (qstrcmp(disambiguation, "North direction terms") == 0 )
1039         return north;
1040     if (qstrcmp(disambiguation, "South direction terms") == 0 )
1041         return south;
1042     if (qstrcmp(disambiguation, "East direction terms") == 0 )
1043         return east;
1044     if (qstrcmp(disambiguation, "West direction terms") == 0 )
1045         return west;
1046     if (qstrcmp(disambiguation, "Degree symbol terms") == 0 )
1047         return degree;
1048     if (qstrcmp(disambiguation, "Minutes symbol terms") == 0 )
1049         return minutes;
1050     if (qstrcmp(disambiguation, "Seconds symbol terms") == 0 )
1051         return seconds;
1052 
1053     return QString();
1054 }
1055 
1056 class Sample
1057 {
1058 public:
1059     Sample() {}
1060     Sample(const char* _name, const char* _string, qreal _lon, qreal _lat)
1061     : name(QString::fromUtf8(_name))
1062     , string(QString::fromUtf8(_string))
1063     , lon(_lon)
1064     , lat(_lat)
1065     {}
1066     QString name;
1067     QString string;
1068     qreal lon;
1069     qreal lat;
1070 };
1071 
1072 class Language {
1073 public:
1074     Language() {}
1075     Language(const char* _name,
1076              const char* _degree, const char* _minutes, const char* _seconds,
1077              const char* _north, const char* _south, const char* _east, const char* _west,
1078              const QVector<Sample>& _samples)
1079     : name(QString::fromUtf8(_name))
1080     , degree(QString::fromUtf8(_degree))
1081     , minutes(QString::fromUtf8(_minutes))
1082     , seconds(QString::fromUtf8(_seconds))
1083     , north(QString::fromUtf8(_north))
1084     , south(QString::fromUtf8(_south))
1085     , east(QString::fromUtf8(_east))
1086     , west(QString::fromUtf8(_west))
1087     , samples(_samples)
1088     {}
1089     QString name;
1090     QString degree;
1091     QString minutes;
1092     QString seconds;
1093     QString north;
1094     QString south;
1095     QString east;
1096     QString west;
1097     QVector<Sample> samples;
1098 };
1099 
1100 void TestGeoDataCoordinates::testFromLocaleString_data()
1101 {
1102     QTest::addColumn<QString>("degree");
1103     QTest::addColumn<QString>("minutes");
1104     QTest::addColumn<QString>("seconds");
1105     QTest::addColumn<QString>("north");
1106     QTest::addColumn<QString>("south");
1107     QTest::addColumn<QString>("east");
1108     QTest::addColumn<QString>("west");
1109 
1110     QTest::addColumn<QString>("string");
1111     QTest::addColumn<qreal>("lon");
1112     QTest::addColumn<qreal>("lat");
1113 
1114     const QVector<Language> languages = QVector<Language>()
1115         << Language(
1116             "English",
1117             "*", // degree
1118             "*", // minutes
1119             "*", // seconds
1120             "*", // north
1121             "*", // south
1122             "*", // east
1123             "*", // west
1124             QVector<Sample>()
1125                 << Sample(
1126                     "London",
1127                     "N051 30.150′ W000 07.234′",
1128                     -0.12056666666666666921, 51.50249999999999772626)
1129                 << Sample(
1130                     "Ålgård",
1131                     "N58.764828 E5.855483",
1132                     5.85548300000000043752, 58.76482800000000139562))
1133 
1134         << Language(
1135             "Japanese",
1136             "度", // degree
1137             "分", // minutes
1138             "秒", // seconds
1139             "北緯", // north
1140             "南緯", // south
1141             "東経", // east
1142             "西経", // west
1143             QVector<Sample>()
1144                 << Sample(
1145                     "London",
1146                     "北緯51度30分28秒 西経0度07分41秒",
1147                     -0.12805555555555556135, 51.50777777777777544088)
1148                 << Sample(
1149                     "Sydney",
1150                     "南緯33度52分06秒 東経151度12分31秒",
1151                     151.20861111111111085847, -33.86833333333333229120))
1152         << Language(
1153             "Korean",
1154             "도", // degree
1155             "분", // minutes
1156             "초", // seconds
1157             "북위", // north
1158             "남위", // south
1159             "동경", // east
1160             "서경", // west
1161             QVector<Sample>()
1162                 << Sample(
1163                     "London",
1164                     "북위 51도 30분 26초, 서경 0도 7분 39초",
1165                     -0.12750000000000000222, 51.50722222222222512755)
1166                 << Sample(
1167                     "Sydney",
1168                     "남위 33도 31분 56초, 동경 151도 12분 40초",
1169                     151.21111111111110858474, -33.53222222222222370647))
1170 
1171 // TODO: allow test control for parsing float in given locale
1172 #if 0
1173         << Language(
1174             "Galician",
1175             "", // degree
1176             "", // minutes
1177             "", // seconds
1178             "N", //north
1179             "S", // south
1180             "L|E", // east
1181             "O|W", // west
1182             QVector<Sample>()
1183                 << Sample(
1184                     "Campamento",
1185                     "36º10,67´N 5º24,29´W",
1186                     -5.40483333333333337833, 36.17783333333333217752))
1187 #endif
1188 
1189         << Language(
1190             "German",
1191             "*", // degree
1192             "*", // minutes
1193             "*", // seconds
1194             "N", //north
1195             "S", // south
1196             "O", // east
1197             "W", // west
1198             QVector<Sample>()
1199                 << Sample(
1200                     "London",
1201                     "51° 31′ N, 0° 7′ W",
1202                     -0.11666666666666666852, 51.51666666666666571928))
1203 
1204         << Language(
1205             "Greek",
1206             "", // degree
1207             "", // minutes
1208             "", // seconds
1209             "Β", // north
1210             "Ν", // south
1211             "Α", // east
1212             "Δ", // west
1213             QVector<Sample>()
1214                 << Sample(
1215                     "Χαλκίδα",
1216                     "38° 28′ Β 23° 36′ Α",
1217                     23.6, 38.46666666666666856))
1218 
1219         << Language(
1220             "Dutch",
1221             "", // degree
1222             "", // minutes
1223             "", // seconds
1224             "N|NB", // north
1225             "Z|ZB", // south
1226             "O|OL", // east
1227             "W|WL", // west
1228             QVector<Sample>()
1229                 << Sample(
1230                     "Amersfoort",
1231                     "N 52° 8′ 32.14″ , E 5° 24′ 56.09″",
1232                     5.41558055555555561966, 52.14226111111111094942)
1233 // TODO: allow test control for parsing float in given locale
1234 #if 0
1235                 << Sample(
1236                     "London",
1237                     "51°30'00,55\" NB 0°07'34,45\" WL",
1238                     -0.12623611111111110450, 51.50015277777777811252)
1239                 << Sample(
1240                     "Amsterdam",
1241                     "52°22'12,78\" NB 4°53'42,60\" OL",
1242                     4.89516666666666644403, 52.37021666666666419587)
1243                 << Sample(
1244                     "Capetown",
1245                     "33°55'29,52\" ZB 18°25'26,60\" OL",
1246                     18.42405555555555451974, -33.92486666666666650372)
1247 #endif
1248                )
1249 
1250         << Language(
1251             "Polish",
1252             "", // degree
1253             "", // minutes
1254             "", // seconds
1255             "Pn.|Pn", // north
1256             "Płd.|Płd", // south
1257             "Wschod.|Wschod|Wsch.|Wsch|Ws.|Ws", // east
1258             "Zach.|Zach|Z", // west
1259             QVector<Sample>()
1260                 << Sample(
1261                     "Warsaw",
1262                     "52°13′56″Pn. 21°00′30″Ws.",
1263                     21.00833333333333285964, 52.23222222222221944321))
1264 
1265 // TODO: allow test control for parsing float in given locale
1266 #if 0
1267         << Language(
1268             "Esperanto",
1269             "", // degree
1270             "", // minutes
1271             "", // seconds
1272             "N", // north
1273             "S", // south
1274             "Or", // east
1275             "Ok", // west
1276             QVector<Sample>()
1277                 << Sample(
1278                     "London",
1279                     "52° 8′ 32,14″ N; 5° 24′ 56,09″ Or",
1280                     5.41558055555555561966, 52.14226111111111094942))
1281 #endif
1282 
1283         << Language(
1284             "Norwegian",
1285             "", // degree
1286             "", // minutes
1287             "", // seconds
1288             "N", // north
1289             "S", // south
1290             "Ø", // east
1291             "V", // west
1292             QVector<Sample>()
1293                 << Sample(
1294                     "London",
1295                     "51° 30′ 25” N 0° 7′ 39” V",
1296                     -0.12750000000000000222, 51.50694444444444286546)
1297                 << Sample(
1298                     "Ålgård",
1299                     "58° 45′ 53.38″ N 5° 51′ 19.74″ Ø",
1300                     5.85548333333333292927, 58.76482777777777499750))
1301 
1302         << Language(
1303             "Swedish",
1304             "", // degree
1305             "", // minutes
1306             "", // seconds
1307             "N", // north
1308             "S", // south
1309             "O", // east
1310             "V", // west
1311             QVector<Sample>()
1312                 << Sample(
1313                     "London",
1314                     "51°30′29″N 0°7′29″V",
1315                     -0.12472222222222222043, 51.50805555555555770297)
1316                 << Sample(
1317                     "Sydney",
1318                     "33°31′56″S 151°12′40″O",
1319                     151.21111111111110858474, -33.53222222222222370647))
1320 
1321         << Language(
1322             "Icelandic",
1323             "", // degree
1324             "", // minutes
1325             "", // seconds
1326             "N", //north
1327             "S", // south
1328             "A", // east
1329             "V", // west
1330 //TODO:     "breidd 51°30'26\" N, lengd 0°7'39\" V" // London
1331             QVector<Sample>()
1332                 << Sample(
1333                     "Sydney",
1334                     "33°31'56\" S, 151°12'40\" A",
1335                     151.21111111111110858474, -33.53222222222222370647))
1336 
1337         << Language(
1338             "Turkish",
1339             "", // degree
1340             "", // minutes
1341             "", // seconds
1342             "K", // north
1343             "G", // south
1344             "D", // east
1345             "B", // west
1346             QVector<Sample>()
1347                 << Sample(
1348                     "London",
1349                     "51° 30′ 28″ K, 0° 7′ 41″ B",
1350                     -0.12805555555555556135, 51.50777777777777544088))
1351 
1352         << Language(
1353             "Spanish", // (incl. Latin America)
1354             "", // degree
1355             "", // minutes
1356             "", // seconds
1357             "N", // north
1358             "S", // south
1359             "E", // east
1360             "O|W", // west
1361             QVector<Sample>()
1362                 << Sample(
1363                     "London",
1364                     "51°30′25″N 00°07′39″O",
1365                     -0.12750000000000000222, 51.50694444444444286546)
1366                 << Sample(
1367                     "Else",
1368                     "52° 8′ 32.14″ N, 5° 24′ 56.09″ W",
1369                     -5.41558055555555561966, 52.14226111111111094942)
1370                 << Sample(
1371                     "Bogotá",
1372                     "4°35’53″N 74°4’33″O",
1373                     -74.07583333333333541759, 4.59805555555555667269))
1374 
1375         << Language(
1376             "French",
1377             "", // degree
1378             "", // minutes
1379             "", // seconds
1380             "N", // north
1381             "S", // south
1382             "E", // east
1383             "O", // west
1384             QVector<Sample>()
1385                 << Sample(
1386                     "London",
1387                     "51° 30′ 18″ N 0° 04′ 43″ O",
1388                     -0.07861111111111110383, 51.50500000000000255795))
1389 
1390         << Language(
1391             "Portuguese", // incl. Brazilian Portuguese
1392             "", // degree
1393             "", // minutes
1394             "", // seconds
1395             "N", // north
1396             "S", // south
1397             "E|L", // east
1398             "O", // west
1399             QVector<Sample>()
1400                 << Sample(
1401                     "London",
1402                     "52° 8′ 32.14″ N, 5° 24′ 56.09″ E",
1403                     5.41558055555555561966, 52.14226111111111094942))
1404 
1405         << Language(
1406             "Arabic",
1407             "", // degree
1408             "", // minutes
1409             "", // seconds
1410     "شمال", // north
1411     "جنوب", // south
1412     "شرق", // east
1413     "غرب", // west
1414             QVector<Sample>()
1415                 << Sample(
1416                     "Warsaw",
1417     "52°13′56″ شمال 21°00′30″ شرق",
1418                     21.00833333333333285964, 52.23222222222221944321))
1419 
1420         << Language(
1421             "Russian",
1422             "", //"град", "градусов" // degree
1423             "", //"мин", "минут" // minutes
1424             "", //"сек", "секунд" // seconds
1425             "с. ш.", // north
1426             "ю. ш.", // south
1427             "в. д.", // east
1428             "з. д.", // west
1429             QVector<Sample>()
1430                 << Sample(
1431                     "London",
1432                     "51°30′26″ с. ш. 0°07′39″ з. д.",
1433                     -0.12750000000000000222, 51.50722222222222512755))
1434 
1435         << Language(
1436             "Ukrainian",
1437             "", // degree
1438             "", // minutes
1439             "", // seconds
1440             "пн. ш.", // north
1441             "пд. ш.", // south
1442             "сх. д.", // east
1443             "зх. д.", // west
1444             QVector<Sample>()
1445                 << Sample(
1446                     "London",
1447                     "51°30' пн. ш. 0°07' сх. д.",
1448                     0.11666666666666666852, 51.50000000000000000000)
1449                 << Sample(
1450                     "Sydney",
1451                     "33°52'10'' пд. ш. 151°12'30'' сх. д.",
1452                     151.20833333333334280724, -33.86944444444444712872)
1453                 << Sample(
1454                     "Rio de Janeiro",
1455                     "22°54'30'' пд. ш. 43°11'47'' зх. д.",
1456                     -43.19638888888889027839, -22.90833333333333499127))
1457 
1458         << Language(
1459             "Bulgarian",
1460             "", // degree
1461             "", // minutes
1462             "", // seconds
1463             "с. ш.", // north
1464             "ю. ш.", // south
1465             "и. д.", // east
1466             "и. д.", // west
1467             QVector<Sample>()
1468                 << Sample(
1469                     "London",
1470                     "51°30′26″ с. ш. 0°07′39″ и. д.",
1471                     0.12750000000000000222, 51.50722222222222512755))
1472 
1473         << Language(
1474             "Czech",
1475             "", // degree
1476             "", // minutes
1477             "", // seconds
1478             "s. š.", // north
1479             "j. š.", // south
1480             "z. d.", // east
1481             "v. d.", // west
1482             QVector<Sample>()
1483                 << Sample(
1484                     "London",
1485                     "51°30′42″ s. š., 0°02′56″ z. d.",
1486                     0.04888888888888889145, 51.51166666666666316132)
1487                 << Sample(
1488                     "Sydney",
1489                     "33° 52′ j. š., 151° 13′ v. d.",
1490                     -151.21666666666669698316, -33.86666666666666714036))
1491 
1492 
1493         << Language(
1494             "Hindi",
1495             "", // degree
1496             "", // minutes
1497             "", // seconds
1498             "उ", // north
1499             "द", // south
1500             "पू", // east
1501             "प", // west
1502             QVector<Sample>()
1503                 << Sample(
1504                     "London",
1505                     "51°30′25″उ 00°07′39″पू",
1506                     0.12750000000000000222, 51.50694444444444286546))
1507 
1508         << Language(
1509             "Tamil",
1510             "", // degree
1511             "", // minutes
1512             "", // seconds
1513             "வ", // north
1514             "தெ", // south
1515             "கி", // east
1516             "மே", // west
1517             QVector<Sample>()
1518                 << Sample(
1519                     "London",
1520                     "51°30′25″ வ 00°07′39″ கி",
1521                     0.12750000000000000222, 51.50694444444444286546))
1522         ;
1523 
1524     foreach( const Language& language, languages ) {
1525     foreach( const Sample& sample, language.samples ) {
1526         const QString rowTitle =
1527             language.name +
1528             QLatin1String("|") + sample.name +
1529             QLatin1String("|lon:") +
1530             QString::number(sample.lon, 'f', 10) +
1531             QLatin1String("|lat:") +
1532             QString::number(sample.lat, 'f', 10);
1533 
1534         QTest::newRow(rowTitle.toLatin1().constData())
1535             << language.degree
1536             << language.minutes
1537             << language.seconds
1538             << language.north
1539             << language.south
1540             << language.east
1541             << language.west
1542             << sample.string
1543             << sample.lon
1544             << sample.lat;
1545         }
1546     }
1547 }
1548 
1549 
1550 void TestGeoDataCoordinates::testFromLocaleString()
1551 {
1552     QFETCH(QString, degree);
1553     QFETCH(QString, minutes);
1554     QFETCH(QString, seconds);
1555     QFETCH(QString, north);
1556     QFETCH(QString, south);
1557     QFETCH(QString, east);
1558     QFETCH(QString, west);
1559 
1560     QFETCH(QString, string);
1561     QFETCH(qreal, lon);
1562     QFETCH(qreal, lat);
1563 
1564     FromStringRegExpTranslator translator(degree, minutes, seconds, north, south, east, west);
1565     QCoreApplication::installTranslator(&translator);
1566 
1567     bool succeeded = false;
1568     const GeoDataCoordinates coords = GeoDataCoordinates::fromString(string, succeeded);
1569 
1570     if(! succeeded)
1571         qWarning() << "Could not parse"<<string <<"for"<<lon<<lat;
1572 
1573     QVERIFY(succeeded);
1574 
1575 // Uncomment to get the lon and lat values with more precision
1576 // qWarning() << "lon"<<QString::number(coords.longitude(GeoDataCoordinates::Degree), 'f', 20)
1577 //            << "lat"<<QString::number(coords.latitude(GeoDataCoordinates::Degree), 'f', 20);
1578 
1579     QCOMPARE(coords.longitude(GeoDataCoordinates::Degree), lon);
1580     QCOMPARE(coords.latitude(GeoDataCoordinates::Degree),  lat);
1581 
1582     QCoreApplication::removeTranslator(&translator);
1583 }
1584 
1585 /*
1586  * test data for toString()
1587  */
1588 void TestGeoDataCoordinates::testToString_Decimal_data()
1589 {
1590     QTest::addColumn<qreal>("lon");
1591     QTest::addColumn<qreal>("lat");
1592     QTest::addColumn<int>("precision");
1593     QTest::addColumn<QString>("expected");
1594 
1595     addRow() << qreal(150.0) << qreal(80.0) << 0 << QString::fromUtf8( " 150°E,   80°N" );
1596     addRow() << qreal(150.0) << qreal(80.0) << 1 << QString::fromUtf8( "150.0°E,  80.0°N" );
1597     addRow() << qreal(150.0) << qreal(80.0) << 2 << QString::fromUtf8( "150.00°E,  80.00°N" );
1598     addRow() << qreal(150.0) << qreal(80.0) << 3 << QString::fromUtf8( "150.000°E,  80.000°N" );
1599     addRow() << qreal(150.0) << qreal(80.0) << 4 << QString::fromUtf8( "150.0000°E,  80.0000°N" );
1600     addRow() << qreal(150.0) << qreal(80.0) << 5 << QString::fromUtf8( "150.00000°E,  80.00000°N" );
1601 
1602     addRow() << qreal(149.6)       << qreal(79.6)       << 0 << QString::fromUtf8( " 150°E,   80°N" );
1603     addRow() << qreal(149.96)      << qreal(79.96)      << 0 << QString::fromUtf8( " 150°E,   80°N" );
1604 
1605     addRow() << qreal(149.6)       << qreal(79.6)       << 1 << QString::fromUtf8( "149.6°E,  79.6°N" );
1606     addRow() << qreal(149.96)      << qreal(79.96)      << 1 << QString::fromUtf8( "150.0°E,  80.0°N" );
1607     addRow() << qreal(149.996)     << qreal(79.996)     << 1 << QString::fromUtf8( "150.0°E,  80.0°N" );
1608 
1609     addRow() << qreal(149.96)      << qreal(79.96)      << 2 << QString::fromUtf8( "149.96°E,  79.96°N" );
1610     addRow() << qreal(149.996)     << qreal(79.996)     << 2 << QString::fromUtf8( "150.00°E,  80.00°N" );
1611     addRow() << qreal(149.9996)    << qreal(79.9996)    << 2 << QString::fromUtf8( "150.00°E,  80.00°N" );
1612 
1613     addRow() << qreal(149.996)     << qreal(79.996)     << 3 << QString::fromUtf8( "149.996°E,  79.996°N" );
1614     addRow() << qreal(149.9996)    << qreal(79.9996)    << 3 << QString::fromUtf8( "150.000°E,  80.000°N" );
1615     addRow() << qreal(149.99996)   << qreal(79.99996)   << 3 << QString::fromUtf8( "150.000°E,  80.000°N" );
1616 
1617     addRow() << qreal(149.9996)    << qreal(79.9996)    << 4 << QString::fromUtf8( "149.9996°E,  79.9996°N" );
1618     addRow() << qreal(149.99996)   << qreal(79.99996)   << 4 << QString::fromUtf8( "150.0000°E,  80.0000°N" );
1619     addRow() << qreal(149.999996)  << qreal(79.999996)  << 4 << QString::fromUtf8( "150.0000°E,  80.0000°N" );
1620 
1621     addRow() << qreal(149.99996)   << qreal(79.99996)   << 5 << QString::fromUtf8( "149.99996°E,  79.99996°N" );
1622     addRow() << qreal(149.999996)  << qreal(79.999996)  << 5 << QString::fromUtf8( "150.00000°E,  80.00000°N" );
1623     addRow() << qreal(149.9999996) << qreal(79.9999996) << 5 << QString::fromUtf8( "150.00000°E,  80.00000°N" );
1624 
1625     addRow() << qreal(149.999996)  << qreal(79.999996)  << 6 << QString::fromUtf8( "149.999996°E,  79.999996°N" );
1626     addRow() << qreal(149.9999996) << qreal(79.9999996) << 6 << QString::fromUtf8( "150.000000°E,  80.000000°N" );
1627 
1628 
1629     addRow() << qreal(150.1)       << qreal(80.1)       << 0 << QString::fromUtf8( " 150°E,   80°N" );
1630     addRow() << qreal(150.01)      << qreal(80.01)      << 0 << QString::fromUtf8( " 150°E,   80°N" );
1631 
1632     addRow() << qreal(150.1)       << qreal(80.1)       << 1 << QString::fromUtf8( "150.1°E,  80.1°N" );
1633     addRow() << qreal(150.01)      << qreal(80.01)      << 1 << QString::fromUtf8( "150.0°E,  80.0°N" );
1634     addRow() << qreal(150.001)     << qreal(80.001)     << 1 << QString::fromUtf8( "150.0°E,  80.0°N" );
1635 
1636     addRow() << qreal(150.01)      << qreal(80.01)      << 2 << QString::fromUtf8( "150.01°E,  80.01°N" );
1637     addRow() << qreal(150.001)     << qreal(80.001)     << 2 << QString::fromUtf8( "150.00°E,  80.00°N" );
1638     addRow() << qreal(150.0001)    << qreal(80.0001)    << 2 << QString::fromUtf8( "150.00°E,  80.00°N" );
1639 
1640     addRow() << qreal(150.001)     << qreal(80.001)     << 3 << QString::fromUtf8( "150.001°E,  80.001°N" );
1641     addRow() << qreal(150.0001)    << qreal(80.0001)    << 3 << QString::fromUtf8( "150.000°E,  80.000°N" );
1642     addRow() << qreal(150.00001)   << qreal(80.00001)   << 3 << QString::fromUtf8( "150.000°E,  80.000°N" );
1643 
1644     addRow() << qreal(150.0001)    << qreal(80.0001)    << 4 << QString::fromUtf8( "150.0001°E,  80.0001°N" );
1645     addRow() << qreal(150.00001)   << qreal(80.00001)   << 4 << QString::fromUtf8( "150.0000°E,  80.0000°N" );
1646     addRow() << qreal(150.000001)  << qreal(80.000001)  << 4 << QString::fromUtf8( "150.0000°E,  80.0000°N" );
1647 
1648     addRow() << qreal(150.00001)   << qreal(80.00001)   << 5 << QString::fromUtf8( "150.00001°E,  80.00001°N" );
1649     addRow() << qreal(150.000001)  << qreal(80.000001)  << 5 << QString::fromUtf8( "150.00000°E,  80.00000°N" );
1650     addRow() << qreal(150.0000001) << qreal(80.0000001) << 5 << QString::fromUtf8( "150.00000°E,  80.00000°N" );
1651 
1652     addRow() << qreal(150.000001)  << qreal(80.000001)  << 6 << QString::fromUtf8( "150.000001°E,  80.000001°N" );
1653     addRow() << qreal(150.0000001) << qreal(80.0000001) << 6 << QString::fromUtf8( "150.000000°E,  80.000000°N" );
1654 }
1655 
1656 /*
1657  * test toString()
1658  */
1659 void TestGeoDataCoordinates::testToString_Decimal()
1660 {
1661     QFETCH( qreal, lon );
1662     QFETCH( qreal, lat );
1663     QFETCH( int, precision );
1664     QFETCH( QString, expected );
1665 
1666     const GeoDataCoordinates coordinates( lon, lat, 0, GeoDataCoordinates::Degree );
1667 
1668     const QString result = coordinates.toString( GeoDataCoordinates::Decimal, precision );
1669     QCOMPARE( result, expected );
1670 }
1671 
1672 /*
1673  * test data for toString()
1674  */
1675 void TestGeoDataCoordinates::testToString_DMS_data()
1676 {
1677     QTest::addColumn<qreal>("lon");
1678     QTest::addColumn<qreal>("lat");
1679     QTest::addColumn<int>("precision");
1680     QTest::addColumn<QString>("expected");
1681 
1682     addRow() << qreal(0.)                         << qreal(0.)                        << 0 << QString::fromUtf8( "  0°E,   0°S" );
1683     addRow() << qreal(150.)                       << qreal(80.)                       << 0 << QString::fromUtf8( "150°E,  80°N" );
1684     addRow() << qreal(149. + 31./60)              << qreal(79. + 31./60)              << 0 << QString::fromUtf8( "150°E,  80°N" );
1685     addRow() << qreal(149. + 30./60 + 31./3600)   << qreal(79. + 30./60 + 31./3600)   << 0 << QString::fromUtf8( "150°E,  80°N" );
1686     addRow() << qreal(149. + 30./60 + 30.51/3600) << qreal(79. + 30./60 + 30.51/3600) << 0 << QString::fromUtf8( "150°E,  80°N" );
1687     addRow() << qreal(150. + 29./60)              << qreal(80. + 29./60)              << 0 << QString::fromUtf8( "150°E,  80°N" );
1688     addRow() << qreal(150. + 29./60 + 29./3600)   << qreal(80. + 29./60 + 29./3600)   << 0 << QString::fromUtf8( "150°E,  80°N" );
1689     addRow() << qreal(150. + 29./60 + 29.49/3600) << qreal(80. + 29./60 + 29.49/3600) << 0 << QString::fromUtf8( "150°E,  80°N" );
1690 
1691     addRow() << qreal(0.)                         << qreal(0.)                        << 1 << QString::fromUtf8( "  0° 00'E,   0° 00'S" );
1692     addRow() << qreal(150.)                       << qreal(80.)                       << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1693     addRow() << qreal(149. + 59./60 + 31./3600)   << qreal(79. + 59./60 + 31./3600)   << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1694     addRow() << qreal(149. + 59./60 + 30.51/3600) << qreal(79. + 59./60 + 30.51/3600) << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1695     addRow() << qreal(150.          + 29./3600)   << qreal(80.          + 29./3600)   << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1696     addRow() << qreal(150.          + 29.49/3600) << qreal(80.          + 29.49/3600) << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1697 
1698     addRow() << qreal(0.)                         << qreal(0.)                        << 2 << QString::fromUtf8( "  0° 00'E,   0° 00'S" );
1699     addRow() << qreal(150.)                       << qreal(80.)                       << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1700     addRow() << qreal(149. + 59./60 + 31./3600)   << qreal(79. + 59./60 + 31./3600)   << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1701     addRow() << qreal(149. + 59./60 + 30.51/3600) << qreal(79. + 59./60 + 30.51/3600) << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1702     addRow() << qreal(150.          + 29./3600)   << qreal(80.          + 29./3600)   << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1703     addRow() << qreal(150.          + 29.49/3600) << qreal(80.          + 29.49/3600) << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1704 
1705     addRow() << qreal(0.)                         << qreal(0.)                        << 3 << QString::fromUtf8( "  0° 00' 00\"E,   0° 00' 00\"S" );
1706     addRow() << qreal(150.)                       << qreal(80.)                       << 3 << QString::fromUtf8( "150° 00' 00\"E,  80° 00' 00\"N" );
1707     addRow() << qreal(149. + 59./60 + 59.51/3600) << qreal(79. + 59./60 + 59.51/3600) << 3 << QString::fromUtf8( "150° 00' 00\"E,  80° 00' 00\"N" );
1708     addRow() << qreal(150.          +  0.49/3600) << qreal(80.          +  0.49/3600) << 3 << QString::fromUtf8( "150° 00' 00\"E,  80° 00' 00\"N" );
1709 
1710     addRow() << qreal(0.)                         << qreal(0.)                        << 4 << QString::fromUtf8( "  0° 00' 00\"E,   0° 00' 00\"S" );
1711     addRow() << qreal(150.)                       << qreal(80.)                       << 4 << QString::fromUtf8( "150° 00' 00\"E,  80° 00' 00\"N" );
1712     addRow() << qreal(149. + 59./60 + 59.51/3600) << qreal(79. + 59./60 + 59.51/3600) << 4 << QString::fromUtf8( "150° 00' 00\"E,  80° 00' 00\"N" );
1713     addRow() << qreal(150.          +  0.49/3600) << qreal(80.          +  0.49/3600) << 4 << QString::fromUtf8( "150° 00' 00\"E,  80° 00' 00\"N" );
1714 
1715     addRow() << qreal(0.)                          << qreal(0.)                         << 5 << QString::fromUtf8( "  0° 00' 00.0\"E,   0° 00' 00.0\"S" );
1716     addRow() << qreal(150.)                        << qreal(80.)                        << 5 << QString::fromUtf8( "150° 00' 00.0\"E,  80° 00' 00.0\"N" );
1717     addRow() << qreal(149. + 59./60 + 59.951/3600) << qreal(79. + 59./60 + 59.951/3600) << 5 << QString::fromUtf8( "150° 00' 00.0\"E,  80° 00' 00.0\"N" );
1718     addRow() << qreal(150.          +  0.049/3600) << qreal(80.          +  0.049/3600) << 5 << QString::fromUtf8( "150° 00' 00.0\"E,  80° 00' 00.0\"N" );
1719 
1720     addRow() << qreal(0.)                           << qreal(0.)                          << 6 << QString::fromUtf8( "  0° 00' 00.00\"E,   0° 00' 00.00\"S" );
1721     addRow() << qreal(150.)                         << qreal(80.)                         << 6 << QString::fromUtf8( "150° 00' 00.00\"E,  80° 00' 00.00\"N" );
1722     addRow() << qreal(149. + 59./60 + 59.9951/3600) << qreal(79. + 59./60 + 59.9951/3600) << 6 << QString::fromUtf8( "150° 00' 00.00\"E,  80° 00' 00.00\"N" );
1723     addRow() << qreal(150.          +  0.0049/3600) << qreal(80.          +  0.0049/3600) << 6 << QString::fromUtf8( "150° 00' 00.00\"E,  80° 00' 00.00\"N" );
1724 }
1725 
1726 /*
1727  * test toString()
1728  */
1729 void TestGeoDataCoordinates::testToString_DMS()
1730 {
1731     QFETCH( qreal, lon );
1732     QFETCH( qreal, lat );
1733     QFETCH( int, precision );
1734     QFETCH( QString, expected );
1735 
1736     const GeoDataCoordinates coordinates( lon, lat, 0, GeoDataCoordinates::Degree );
1737 
1738     const QString result = coordinates.toString( GeoDataCoordinates::DMS, precision );
1739     QCOMPARE( result, expected );
1740 }
1741 
1742 /*
1743  * test data for toString()
1744  */
1745 void TestGeoDataCoordinates::testToString_DM_data()
1746 {
1747     QTest::addColumn<qreal>("lon");
1748     QTest::addColumn<qreal>("lat");
1749     QTest::addColumn<int>("precision");
1750     QTest::addColumn<QString>("expected");
1751 
1752     addRow() << qreal(0.)              << qreal(0.)             << 0 << QString::fromUtf8( "  0°E,   0°S" );
1753     addRow() << qreal(150.)            << qreal(80.)            << 0 << QString::fromUtf8( "150°E,  80°N" );
1754     addRow() << qreal(149. + 31./60)   << qreal(79. + 31./60)   << 0 << QString::fromUtf8( "150°E,  80°N" );
1755     addRow() << qreal(149. + 30.51/60) << qreal(79. + 30.51/60) << 0 << QString::fromUtf8( "150°E,  80°N" );
1756     addRow() << qreal(150. + 29./60)   << qreal(80. + 29./60)   << 0 << QString::fromUtf8( "150°E,  80°N" );
1757     addRow() << qreal(150. + 29.49/60) << qreal(80. + 29.49/60) << 0 << QString::fromUtf8( "150°E,  80°N" );
1758 
1759     addRow() << qreal(0.)              << qreal(0.)             << 1 << QString::fromUtf8( "  0° 00'E,   0° 00'S" );
1760     addRow() << qreal(150.)            << qreal(80.)            << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1761     addRow() << qreal(149. + 59.51/60) << qreal(79. + 59.51/60) << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1762     addRow() << qreal(150. +  0.49/60) << qreal(80. +  0.49/60) << 1 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1763 
1764     addRow() << qreal(0.)              << qreal(0.)             << 2 << QString::fromUtf8( "  0° 00'E,   0° 00'S" );
1765     addRow() << qreal(150.)            << qreal(80.)            << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1766     addRow() << qreal(149. + 59.51/60) << qreal(79. + 59.51/60) << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1767     addRow() << qreal(150. +  0.49/60) << qreal(80. +  0.49/60) << 2 << QString::fromUtf8( "150° 00'E,  80° 00'N" );
1768 
1769     addRow() << qreal(0.)               << qreal(0.)              << 3 << QString::fromUtf8( "  0° 00.0'E,   0° 00.0'S" );
1770     addRow() << qreal(150.)             << qreal(80.)             << 3 << QString::fromUtf8( "150° 00.0'E,  80° 00.0'N" );
1771     addRow() << qreal(149. + 59.951/60) << qreal(79. + 59.951/60) << 3 << QString::fromUtf8( "150° 00.0'E,  80° 00.0'N" );
1772     addRow() << qreal(150. +  0.049/60) << qreal(80. +  0.049/60) << 3 << QString::fromUtf8( "150° 00.0'E,  80° 00.0'N" );
1773 
1774     addRow() << qreal(0.)                << qreal(0.)               << 4 << QString::fromUtf8( "  0° 00.00'E,   0° 00.00'S" );
1775     addRow() << qreal(150.)              << qreal(80.)              << 4 << QString::fromUtf8( "150° 00.00'E,  80° 00.00'N" );
1776     addRow() << qreal(149. + 59.9951/60) << qreal(79. + 59.9951/60) << 4 << QString::fromUtf8( "150° 00.00'E,  80° 00.00'N" );
1777     addRow() << qreal(150. +  0.0049/60) << qreal(80. +  0.0049/60) << 4 << QString::fromUtf8( "150° 00.00'E,  80° 00.00'N" );
1778 }
1779 
1780 /*
1781  * test toString()
1782  */
1783 void TestGeoDataCoordinates::testToString_DM()
1784 {
1785     QFETCH( qreal, lon );
1786     QFETCH( qreal, lat );
1787     QFETCH( int, precision );
1788     QFETCH( QString, expected );
1789 
1790     const GeoDataCoordinates coordinates( lon, lat, 0, GeoDataCoordinates::Degree );
1791 
1792     const QString result = coordinates.toString( GeoDataCoordinates::DM, precision );
1793     QCOMPARE( result, expected );
1794 }
1795 
1796 /*
1797  * test data for testPack()
1798  */
1799 void TestGeoDataCoordinates::testPack_data()
1800 {
1801     QTest::addColumn<qreal>("lon");
1802     QTest::addColumn<qreal>("lat");
1803     QTest::addColumn<qreal>("alt");
1804 
1805     QTest::newRow("deg") << qreal(180.0) << qreal(90.0) << qreal(400.0);
1806 }
1807 
1808 /*
1809  * test pack() and unPack()
1810  */
1811 void TestGeoDataCoordinates::testPack()
1812 {
1813     QFETCH(qreal, lon);
1814     QFETCH(qreal, lat);
1815     QFETCH(qreal, alt);
1816 
1817     GeoDataCoordinates coordinates1,coordinates2;
1818     coordinates1.set(lon, lat, alt, GeoDataCoordinates::Degree);
1819 
1820     QTemporaryFile file;
1821     if(file.open()) {
1822         QDataStream out(&file);
1823         coordinates1.pack(out);
1824     }
1825     file.close();
1826 
1827     if(file.open()) {
1828         QDataStream in(&file);
1829         coordinates2.unpack(in);
1830     }
1831     file.close();
1832 
1833     QCOMPARE(coordinates1.longitude(GeoDataCoordinates::Degree), coordinates2.longitude(GeoDataCoordinates::Degree));
1834     QCOMPARE(coordinates1.latitude(GeoDataCoordinates::Degree), coordinates2.latitude(GeoDataCoordinates::Degree));
1835     QCOMPARE(coordinates1.altitude(), coordinates2.altitude());
1836 }
1837 
1838 /*
1839  * test data for testUTM()
1840  */
1841 void TestGeoDataCoordinates::testUTM_data()
1842 {
1843     QTest::addColumn<qreal>("lon");
1844     QTest::addColumn<qreal>("lat");
1845     QTest::addColumn<int>("zone");
1846     QTest::addColumn<QString>("latitudeBand");
1847     QTest::addColumn<int>("easting");
1848     QTest::addColumn<int>("northing");
1849 
1850     /* Randomly selected locations, converted to UTM with the following
1851      * tools to check their correctness:
1852      * http://home.hiwaay.net/~taylorc/toolbox/geography/geoutm.html
1853      * http://www.earthpoint.us/Convert.aspx
1854      * http://www.synnatschke.de/geo-tools/coordinate-converter.php
1855      * http://www.latlong.net/lat-long-utm.html
1856      * http://leware.net/geo/utmgoogle.htm
1857      * http://geographiclib.sourceforge.net/cgi-bin/GeoConvert
1858      */
1859 
1860     // Equator
1861     addRow() << qreal(-180.0)   << qreal(0.0)       << 1  << "N" << 16602144 << 0;
1862     addRow() << qreal(0)        << qreal(0.0)       << 31 << "N" << 16602144 << 0;
1863     addRow() << qreal(150.567)  << qreal(0.0)       << 56 << "N" << 22918607 << 0;
1864 
1865     // Zone borders
1866     int zoneNumber = 1;
1867     for ( int i = -180; i <= 180; i += 6 ){
1868         addRow() << qreal(i) << qreal(0.0) << zoneNumber << "N" << 16602144 << 0;
1869         zoneNumber++;
1870     }
1871 
1872     // Northern hemisphere
1873     addRow() << qreal(-180.0)   << qreal(15)        << 1  << "P" << 17734904 << 166051369;
1874     addRow() << qreal(0)        << qreal(60.5)      << 31 << "V" << 33523714 << 671085271;
1875     addRow() << qreal(150.567)  << qreal(75.123)    << 56 << "X" << 43029080 << 833876115;
1876 
1877     // Southern hemisphere
1878     addRow() << qreal(-3.5)     << qreal(-50)       << 30 << "F" << 46416654 << 446124952;
1879     addRow() << qreal(22.56)    << qreal(-62.456)   << 34 << "E" << 58047905 << 307404780;
1880 
1881     // Exceptions
1882 
1883     // North pole (no zone associated, so it returns 0)
1884     addRow() << qreal(-100.0)   << qreal(85.0)      << 0  << "Y" << 49026986 << 943981733;
1885     addRow() << qreal(100.0)    << qreal(85.0)      << 0  << "Z" << 50973014 << 943981733;
1886 
1887     // South pole (no zone associated, so it returns 0)
1888     addRow() << qreal(-100.0)   << qreal(-85.0)     << 0  << "A" << 49026986 << 56018267;
1889     addRow() << qreal(100.0)    << qreal(-85.0)     << 0  << "B" << 50973014 << 56018267;
1890 
1891     // Stavanger, in southwestern Norway, is in zone 32
1892     addRow() << qreal(5.73)     << qreal(58.97)     << 32 << "V" << 31201538 << 654131013;
1893     // Same longitude, at the equator, is in zone 31
1894     addRow() << qreal(5.73)     << qreal(0.0)       << 31 << "N" << 80389643 << 0;
1895 
1896     // Svalbard is in zone 33
1897     addRow() << qreal(10.55)    << qreal(78.88)     << 33 << "X" << 40427848 << 876023047;
1898     // Same longitude, at the equator, is in zone 32
1899     addRow() << qreal(10.55)    << qreal(0.0)       << 32 << "N" << 67249738 << 0;
1900 }
1901 
1902 /*
1903  * test UTM-related functions:
1904  *     - utmZone()
1905  *     - utmLatitudeBand()
1906  *     - utmEasting()
1907  *     - utmNorthing()
1908  */
1909 void TestGeoDataCoordinates::testUTM(){
1910     QFETCH(qreal, lon);
1911     QFETCH(qreal, lat);
1912     QFETCH(int, zone);
1913     QFETCH(QString, latitudeBand);
1914     QFETCH(int, easting);
1915     QFETCH(int, northing);
1916 
1917     GeoDataCoordinates coordinates;
1918     coordinates.set(lon, lat, 0, GeoDataCoordinates::Degree);
1919 
1920     QCOMPARE(coordinates.utmZone(), zone);
1921     QCOMPARE(coordinates.utmLatitudeBand(), latitudeBand);
1922 
1923     /* Comparing integers is safer than comparing qreals. As the expected
1924      * values are expressed in centimeters, the actual values are converted
1925      * to this unit.
1926      */
1927     int actualEasting = qRound( 100.0 * coordinates.utmEasting() );
1928     int actualNorthing = qRound( 100.0 * coordinates.utmNorthing() );
1929 
1930     QCOMPARE( actualEasting, easting );
1931     QCOMPARE( actualNorthing, northing );
1932 }
1933 
1934 QTEST_MAIN(TestGeoDataCoordinates)
1935 #include "TestGeoDataCoordinates.moc"
1936 
1937 
1938