/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "../qlocationtestutils_p.h"

#include <qgeocoordinate.h>

#include <qtest.h>

#include <QMetaType>

#include <QDebug>

#include <float.h>

QTM_USE_NAMESPACE

Q_DECLARE_METATYPE(QGeoCoordinate)

Q_DECLARE_METATYPE(QGeoCoordinate::CoordinateFormat)

Q_DECLARE_METATYPE(QGeoCoordinate::CoordinateType)

static const QGeoCoordinate BRISBANE(-27.46758, 153.027892);

static const QGeoCoordinate MELBOURNE(-37.814251, 144.963169);

static const QGeoCoordinate LONDON(51.500152, -0.126236);

static const QGeoCoordinate NEW_YORK(40.71453, -74.00713);

static const QGeoCoordinate NORTH_POLE(90, 0);

static const QGeoCoordinate SOUTH_POLE(-90, 0);

static const QChar DEGREES_SYMB(0x00B0);

QByteArray tst_qgeocoordinate_debug;

void tst_qgeocoordinate_messageHandler(QtMsgType type, const char *msg)

{

    switch(type) {

        case QtDebugMsg :

            tst_qgeocoordinate_debug = QByteArray(msg);

            break;

        default:

            break;

    }

}

class tst_QGeoCoordinate : public QObject

{

    Q_OBJECT

private:

    enum TestDataType {

        Latitude,

        Longitude,

        Altitude

    };

private slots:

    void constructor()

    {

        QGeoCoordinate c;

        QVERIFY(!c.isValid());

        QCOMPARE(c, QGeoCoordinate());

    }

    void constructor_lat_long()

    {

        QFETCH(double, latitude);

        QFETCH(double, longitude);

        QFETCH(QGeoCoordinate::CoordinateType, type);

        QGeoCoordinate c(latitude, longitude);

        QCOMPARE(c.type(), type);

        if (type != QGeoCoordinate::InvalidCoordinate) {

            QVERIFY(c.isValid());

            QCOMPARE(c.latitude(), latitude);

            QCOMPARE(c.longitude(), longitude);

        } else {

            QVERIFY(!c.isValid());

            QVERIFY(c.latitude() != latitude);

            QVERIFY(c.longitude() != longitude);

        }

    }

    void constructor_lat_long_data()

    {

        QTest::addColumn<double>("latitude");

        QTest::addColumn<double>("longitude");

        QTest::addColumn<QGeoCoordinate::CoordinateType>("type");

        QTest::newRow("both zero") << 0.0 << 0.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("both negative") << -1.0 << -1.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("both positive") << 1.0 << 1.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("latitude negative") << -1.0 << 1.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("longitude negative") << 1.0 << -1.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("both too high") << 90.1 << 180.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("latitude too high") << 90.1 << 0.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("longitude too high") << 0.1 << 180.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("both too low") << -90.1 << -180.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("latitude too low") << -90.1 << 0.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("longitude too low") << 0.1 << -180.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("both not too high") << 90.0 << 180.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("both not too low") << -90.0 << -180.0 << QGeoCoordinate::Coordinate2D;

        QTest::newRow("latitude too high and longitude too low") << 90.1 << -180.1 << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("latitude too low and longitude too high") << -90.1 << 180.1 << QGeoCoordinate::InvalidCoordinate;

    }

    void constructor_lat_long_alt()

    {

        QFETCH(double, latitude);

        QFETCH(double, longitude);

        QFETCH(double, altitude);

        QFETCH(QGeoCoordinate::CoordinateType, type);

        QGeoCoordinate c(latitude, longitude, altitude);

        QCOMPARE(c.type(), type);

        if (type != QGeoCoordinate::InvalidCoordinate) {

            QCOMPARE(c.latitude(), latitude);

            QCOMPARE(c.longitude(), longitude);

            QCOMPARE(c.altitude(), altitude);

        } else {

            QVERIFY(!c.isValid());

            QVERIFY(c.latitude() != latitude);

            QVERIFY(c.longitude() != longitude);

            QVERIFY(c.altitude() != altitude);

        }

    }

    void constructor_lat_long_alt_data()

    {

        QTest::addColumn<double>("latitude");

        QTest::addColumn<double>("longitude");

        QTest::addColumn<double>("altitude");

        QTest::addColumn<QGeoCoordinate::CoordinateType>("type");

        QTest::newRow("all zero") << 0.0 << 0.0 << 0.0 << QGeoCoordinate::Coordinate3D;

        QTest::newRow("all negative") << -1.0 << -1.0 << -2.0 << QGeoCoordinate::Coordinate3D;

        QTest::newRow("all positive") << 1.0 << 1.0 << 4.0 << QGeoCoordinate::Coordinate3D;

        QTest::newRow("latitude negative") << -1.0 << 1.0 << 1.0 << QGeoCoordinate::Coordinate3D;

        QTest::newRow("longitude negative") << 1.0 << -1.0  << 1.0 << QGeoCoordinate::Coordinate3D;

        QTest::newRow("altitude negative") << 1.0 << 1.0  << -1.0 << QGeoCoordinate::Coordinate3D;

        QTest::newRow("altitude not too high") << 1.0 << 1.0  << DBL_MAX << QGeoCoordinate::Coordinate3D;

        QTest::newRow("altitude not too low") << 1.0 << 1.0  << DBL_MIN << QGeoCoordinate::Coordinate3D;

        QTest::newRow("all not too high") << 90.0 << 180.0  << DBL_MAX << QGeoCoordinate::Coordinate3D;

        QTest::newRow("all not too low") << -90.0 << -180.0  << DBL_MIN << QGeoCoordinate::Coordinate3D;

        QTest::newRow("all too high") << 90.1 << 180.1 << DBL_MAX << QGeoCoordinate::InvalidCoordinate;

        QTest::newRow("all too low") << -90.1 << -180.1 << DBL_MIN << QGeoCoordinate::InvalidCoordinate;

    }

    void copy_constructor()

    {

        QFETCH(QGeoCoordinate, c);

        QGeoCoordinate copy(c);

        QCOMPARE(copy.type(), c.type());

        if (c.type() != QGeoCoordinate::InvalidCoordinate) {

            QCOMPARE(copy.latitude(), c.latitude());

            QCOMPARE(copy.longitude(), c.longitude());

            if (c.type() == QGeoCoordinate::Coordinate3D)

                QCOMPARE(copy.altitude(), c.altitude());

        }

    }

    void copy_constructor_data()

    {

        QTest::addColumn<QGeoCoordinate>("c");

        QTest::newRow("no argument") << QGeoCoordinate();

        QTest::newRow("latitude, longitude arguments all zero") << QGeoCoordinate(0.0, 0.0);

        QTest::newRow("latitude, longitude arguments not too high") << QGeoCoordinate(90.0, 180.0);

        QTest::newRow("latitude, longitude arguments not too low") << QGeoCoordinate(-90.0, -180.0);

        QTest::newRow("latitude, longitude arguments too high") << QGeoCoordinate(90.1, 180.1);

        QTest::newRow("latitude, longitude arguments too low") << QGeoCoordinate(-90.1, -180.1);

        QTest::newRow("latitude, longitude, altitude arguments all zero") << QGeoCoordinate(0.0, 0.0, 0.0);

        QTest::newRow("latitude, longitude, altitude arguments not too high values") << QGeoCoordinate(90.0, 180.0, DBL_MAX);

        QTest::newRow("latitude, longitude, altitude arguments not too low values") << QGeoCoordinate(-90.0, -180.0, DBL_MIN);

        QTest::newRow("latitude, longitude, altitude arguments too high latitude & longitude") << QGeoCoordinate(90.1, 180.1, DBL_MAX);

        QTest::newRow("latitude, longitude, altitude arguments too low latitude & longitude") << QGeoCoordinate(-90.1, -180.1, DBL_MAX);

    }

    void destructor()

    {

        QGeoCoordinate *coordinate;

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate();

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate(0.0, 0.0);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate(0.0, 0.0, 0.0);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate(90.0, 180.0);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate(-90.0, -180.0);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate(90.1, 180.1);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

        QLocationTestUtils::uheap_mark();

        coordinate = new QGeoCoordinate(-90.1, -180.1);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

    }

    void destructor2()

    {

        QFETCH(QGeoCoordinate, c);

        QLocationTestUtils::uheap_mark();

        QGeoCoordinate *coordinate = new QGeoCoordinate(c);

        delete coordinate;

        QLocationTestUtils::uheap_mark_end();

    }

    void destructor2_data()

    {

        copy_constructor_data();

    }

    void assign()

    {

        QFETCH(QGeoCoordinate, c);

        QGeoCoordinate c1 = c;

        QCOMPARE(c.type(), c1.type());

        if (c.isValid()) {

            QCOMPARE(c.latitude(), c.latitude());

            QCOMPARE(c.longitude(), c.longitude());

            if (c.type() == QGeoCoordinate::Coordinate3D)

                QCOMPARE(c.altitude(), c.altitude());

        }

    }

    void assign_data()

    {

        copy_constructor_data();

    }

    void comparison()

    {

        QFETCH(QGeoCoordinate, c1);

        QFETCH(QGeoCoordinate, c2);

        QFETCH(bool, result);

        QCOMPARE(c1 == c2, result);

    }

    void comparison_data()

    {

        QTest::addColumn<QGeoCoordinate>("c1");

        QTest::addColumn<QGeoCoordinate>("c2");

        QTest::addColumn<bool>("result");

        QTest::newRow("Invalid != BRISBANE")

                << QGeoCoordinate(-190,-1000) << BRISBANE << false;

        QTest::newRow("BRISBANE != MELBOURNE")

                << BRISBANE << MELBOURNE << false;

        QTest::newRow("equal")

                << BRISBANE << BRISBANE << true;

        QTest::newRow("LONDON != uninitialized data")

                << LONDON << QGeoCoordinate() << false;

        QTest::newRow("uninitialized data == uninitialized data")

                << QGeoCoordinate() << QGeoCoordinate() << true;

        QTest::newRow("invalid == same invalid")

                << QGeoCoordinate(-190,-1000) << QGeoCoordinate(-190,-1000) << true;

        QTest::newRow("invalid == different invalid")

                << QGeoCoordinate(-190,-1000) << QGeoCoordinate(190,1000) << true;

        QTest::newRow("valid != another valid")

                << QGeoCoordinate(-90,-180) << QGeoCoordinate(-45,+45) << false;

        QTest::newRow("valid == same valid")

                << QGeoCoordinate(-90,-180) << QGeoCoordinate(-90,-180) << true;

    }

    void type()

    {

        QFETCH(QGeoCoordinate, c);

        QFETCH(QGeoCoordinate::CoordinateType, type);

        QCOMPARE(c.type(), type);

    }

    void type_data()

    {

        QTest::addColumn<QGeoCoordinate>("c");

        QTest::addColumn<QGeoCoordinate::CoordinateType>("type");

        QGeoCoordinate c;

        QTest::newRow("no values set")  << c << QGeoCoordinate::InvalidCoordinate;

        c.setAltitude(1.0);

        QTest::newRow("only altitude is set")  << c << QGeoCoordinate::InvalidCoordinate;

        c.setLongitude(1.0);

        QTest::newRow("only latitude and altitude is set") << c << QGeoCoordinate::InvalidCoordinate;

        c.setLatitude(-1.0);

        QTest::newRow("all valid: 3D Coordinate") << c << QGeoCoordinate::Coordinate3D;

        c.setLatitude(-90.1);

        QTest::newRow("too low latitude and valid longitude") << c << QGeoCoordinate::InvalidCoordinate;

        c.setLongitude(-180.1);

        c.setLatitude(90.0);

        QTest::newRow("valid latitude and too low longitude") << c << QGeoCoordinate::InvalidCoordinate;

        c.setLatitude(90.1);

        c.setLongitude(-180.0);

        QTest::newRow("too high latitude and valid longitude") << c << QGeoCoordinate::InvalidCoordinate;

        c.setLatitude(-90.0);

        c.setLongitude(180.1);

        QTest::newRow("valid latitude and too high longitude") << c << QGeoCoordinate::InvalidCoordinate;

    }

    void valid()

    {

        QFETCH(QGeoCoordinate, c);

        QCOMPARE(c.isValid(), c.type() != QGeoCoordinate::InvalidCoordinate);

    }

    void valid_data()

    {

        type_data();

    }

    void addDataValues(TestDataType type)

    {

        QTest::addColumn<double>("value");

        QTest::addColumn<bool>("valid");

        QTest::newRow("negative") << -1.0 << true;

        QTest::newRow("zero") << 0.0 << true;

        QTest::newRow("positive") << 1.0 << true;

        switch (type) {

            case Latitude:

                QTest::newRow("too low") << -90.1 << false;

                QTest::newRow("not too low") << -90.0 << true;

                QTest::newRow("not too hight") << 90.0 << true;

                QTest::newRow("too high") << 90.1;

                break;

            case Longitude:

                QTest::newRow("too low") << -180.1 << false;

                QTest::newRow("not too low") << -180.0 << true;

                QTest::newRow("not too hight") << 180.0 << true;

                QTest::newRow("too high") << 180.1;

                break;

            case Altitude:

                break;

        }

    }

    void latitude()

    {

        QFETCH(double, value);

        QGeoCoordinate c;

        c.setLatitude(value);

        QCOMPARE(c.latitude(), value);

        QGeoCoordinate c2 = c;

        QCOMPARE(c.latitude(), value);

        QCOMPARE(c2, c);

    }

    void latitude_data() { addDataValues(Latitude); }

    void longitude()

    {

        QFETCH(double, value);

        QGeoCoordinate c;

        c.setLongitude(value);

        QCOMPARE(c.longitude(), value);

        QGeoCoordinate c2 = c;

        QCOMPARE(c.longitude(), value);

        QCOMPARE(c2, c);

    }

    void longitude_data() { addDataValues(Longitude); }

    void altitude()

    {

        QFETCH(double, value);

        QGeoCoordinate c;

        c.setAltitude(value);

        QCOMPARE(c.altitude(), value);

        QGeoCoordinate c2 = c;

        QCOMPARE(c.altitude(), value);

        QCOMPARE(c2, c);

    }

    void altitude_data() { addDataValues(Altitude); }

    void distanceTo()

    {

        QFETCH(QGeoCoordinate, c1);

        QFETCH(QGeoCoordinate, c2);

        QFETCH(qreal, distance);

        QCOMPARE(QString::number(c1.distanceTo(c2)), QString::number(distance));

    }

    void distanceTo_data()

    {

        QTest::addColumn<QGeoCoordinate>("c1");

        QTest::addColumn<QGeoCoordinate>("c2");

        QTest::addColumn<qreal>("distance");

        QTest::newRow("invalid coord 1")

                << QGeoCoordinate() << BRISBANE << qreal(0.0);

        QTest::newRow("invalid coord 2")

                << BRISBANE << QGeoCoordinate() << qreal(0.0);

        QTest::newRow("brisbane -> melbourne")

                << BRISBANE << MELBOURNE << qreal(1374820.1618767744);

        QTest::newRow("london -> new york")

                << LONDON << NEW_YORK << qreal(5570538.4987236429);

        QTest::newRow("north pole -> south pole")

                << NORTH_POLE << SOUTH_POLE << qreal(20015109.4154876769);

    }

    void azimuthTo()

    {

        QFETCH(QGeoCoordinate, c1);

        QFETCH(QGeoCoordinate, c2);

        QFETCH(qreal, azimuth);

        QCOMPARE(QString::number(c1.azimuthTo(c2)), QString::number(azimuth));

    }

    void azimuthTo_data()

    {

        QTest::addColumn<QGeoCoordinate>("c1");

        QTest::addColumn<QGeoCoordinate>("c2");

        QTest::addColumn<qreal>("azimuth");

        QTest::newRow("invalid coord 1")

                << QGeoCoordinate() << BRISBANE << qreal(0.0);

        QTest::newRow("invalid coord 2")

                << BRISBANE << QGeoCoordinate() << qreal(0.0);

        QTest::newRow("brisbane -> melbourne")

                << BRISBANE << MELBOURNE << qreal(211.1717286649);

        QTest::newRow("london -> new york")

                << LONDON << NEW_YORK << qreal(288.3388804508);

        QTest::newRow("north pole -> south pole")

                << NORTH_POLE << SOUTH_POLE << qreal(180.0);

    }

    void degreesToString()

    {

        QFETCH(QGeoCoordinate, coord);

        QFETCH(QGeoCoordinate::CoordinateFormat, format);

        QFETCH(QString, string);

        QCOMPARE(coord.toString(format), string);

    }

    void degreesToString_data()

    {

        QTest::addColumn<QGeoCoordinate>("coord");

        QTest::addColumn<QGeoCoordinate::CoordinateFormat>("format");

        QTest::addColumn<QString>("string");

        QGeoCoordinate northEast(27.46758, 153.027892);

        QGeoCoordinate northEastWithAlt(27.46758, 153.027892, 28.23411);

        QGeoCoordinate southEast(-27.46758, 153.027892);

        QGeoCoordinate southEastWithAlt(-27.46758, 153.027892, 28.23411);

        QGeoCoordinate northWest(27.46758, -153.027892);

        QGeoCoordinate northWestWithAlt(27.46758, -153.027892, 28.23411);

        QGeoCoordinate southWest(-27.46758, -153.027892);

        QGeoCoordinate southWestWithAlt(-27.46758, -153.027892, 28.23411);