tst_qgeolocation.cpp

qt/qtpositioning/tests/auto/qgeolocation/tst_qgeolocation.cpp (file symbol)

Enable keyboard shortcuts

Source code

Go to header file

Revision control

Copy as Markdown

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "tst_qgeolocation.h"

#include <QtPositioning/QGeoCircle>

#include <QtPositioning/QGeoPolygon>

QT_USE_NAMESPACE

tst_QGeoLocation::tst_QGeoLocation()

void tst_QGeoLocation::initTestCase()

void tst_QGeoLocation::cleanupTestCase()

void tst_QGeoLocation::init()

void tst_QGeoLocation::cleanup()

void tst_QGeoLocation::constructor()

    QCOMPARE(m_location.address(), m_address);

    QCOMPARE(m_location.coordinate(), m_coordinate);

    QCOMPARE(m_location.boundingShape(), m_viewport);

    QCOMPARE(m_location.extendedAttributes(), m_extendedAttributes);

void tst_QGeoLocation::copy_constructor()

    auto qgeolocationcopy = std::make_unique<QGeoLocation>(m_location);

    QCOMPARE(m_location, *qgeolocationcopy);

void tst_QGeoLocation::move_constructor()

    QGeoAddress address;

    address.setCity("Berlin");

    address.setCountry("Germany");

    address.setCountryCode("DEU");

    address.setDistrict("Adlershof");

    address.setPostalCode("12489");

    address.setStreet("Erich-Thilo-Strasse");

    QGeoLocation location;

    location.setAddress(address);

    location.setCoordinate(QGeoCoordinate(1.3, 2.4, 3.1));

    location.setBoundingShape(QGeoCircle(QGeoCoordinate(1.3, 2.4), 100));

    QGeoLocation locationCopy = location;

    QCOMPARE(std::move(location), locationCopy);

void tst_QGeoLocation::move_assignment()

    QGeoAddress address;

    address.setCity("Berlin");

    address.setCountry("Germany");

    address.setCountryCode("DEU");

    address.setDistrict("Adlershof");

    address.setPostalCode("12489");

    address.setStreet("Erich-Thilo-Strasse");

    QGeoLocation location;

    location.setAddress(address);

    location.setCoordinate(QGeoCoordinate(1.3, 2.4, 3.1));

    location.setBoundingShape(QGeoCircle(QGeoCoordinate(1.3, 2.4), 100));

    QGeoLocation locationCopy = location;

    QGeoLocation otherLocation;

    otherLocation = std::move(location);

    QCOMPARE(otherLocation, locationCopy);

    // Check that (move)assignment to a moved-from object is fine

    location = std::move(locationCopy);

    QCOMPARE(location, otherLocation);

void tst_QGeoLocation::destructor()

    QGeoLocation *qgeolocationcopy;

    qgeolocationcopy = new QGeoLocation();

    delete qgeolocationcopy;

    qgeolocationcopy = new QGeoLocation(m_location);

    delete qgeolocationcopy;

void tst_QGeoLocation::address()

    m_address.setCity("Berlin");

    m_address.setCountry("Germany");

    m_address.setCountryCode("DEU");

    m_address.setDistrict("Mitte");

    m_address.setPostalCode("10115");

    m_address.setStreet("Invalidenstrasse");

    m_location.setAddress(m_address);

    QCOMPARE(m_location.address(),m_address);

    m_address.setPostalCode("10125");

    QVERIFY(m_location.address() != m_address);

void tst_QGeoLocation::coordinate()

    m_coordinate.setLatitude(13.3851);

    m_coordinate.setLongitude(52.5312);

    m_coordinate.setAltitude(134.23);

    m_location.setCoordinate(m_coordinate);

    QCOMPARE(m_location.coordinate(), m_coordinate);

    m_coordinate.setAltitude(0);

    QVERIFY(m_location.coordinate() != m_coordinate);

void tst_QGeoLocation::viewport()

    m_coordinate.setLatitude(13.3851);

    m_coordinate.setLongitude(52.5312);

    // rectangle bounding box

    QGeoRectangle qgeoboundingboxcopy(m_coordinate, 0.4, 0.4);

    m_location.setBoundingShape(qgeoboundingboxcopy);

    QCOMPARE(m_location.boundingShape(), qgeoboundingboxcopy);

    // test that QGeoShape::boundingGeoRectangle() matches with

    // the qgeoboundingboxcopy. It simplifies code porting

    QCOMPARE(m_location.boundingShape().boundingGeoRectangle(), qgeoboundingboxcopy);

    qgeoboundingboxcopy.setHeight(1);

    QVERIFY(m_location.boundingShape() != qgeoboundingboxcopy);

    // circle bounding box

    QGeoCircle circle(m_coordinate, 10);

    m_location.setBoundingShape(circle);

    QCOMPARE(m_location.boundingShape(), circle);

    auto point = QGeoCoordinate(0.5, 0.5);

    QVERIFY(!circle.contains(point));

    circle.extendCircle(point);

    QVERIFY(m_location.boundingShape() != circle);

    QVERIFY(!m_location.boundingShape().contains(point));

    // polygon bounding box

    const QList<QGeoCoordinate> points = {QGeoCoordinate(1.0, 1.0), QGeoCoordinate(1.0, 2.0), QGeoCoordinate(2.0, 2.0)};

    QGeoPolygon polygon(points);

    point = QGeoCoordinate(1.75, 1.25);

    QVERIFY(!polygon.contains(point));

    m_location.setBoundingShape(polygon);

    QCOMPARE(m_location.boundingShape(), polygon);

    polygon.addCoordinate(QGeoCoordinate(2.0, 1.0));

    QVERIFY(m_location.boundingShape() != polygon);

    QVERIFY(polygon.contains(point));

    QVERIFY(!m_location.boundingShape().contains(point));

void tst_QGeoLocation::extendedAttributes()

    m_extendedAttributes = QVariantMap({{ "foo" , 42 }});

    m_location.setExtendedAttributes(m_extendedAttributes);

    QCOMPARE(m_location.extendedAttributes(), m_extendedAttributes);

    m_extendedAttributes["foo"] = 41;

    QVERIFY(m_location.extendedAttributes() != m_extendedAttributes);

void tst_QGeoLocation::operators()

    QGeoAddress qgeoaddresscopy;

    qgeoaddresscopy.setCity("Berlin");

    qgeoaddresscopy.setCountry("Germany");

    qgeoaddresscopy.setCountryCode("DEU");

    QGeoCoordinate qgeocoordinatecopy (32.324 , 41.324 , 24.55);

    QVariantMap extendedAttributesCopy {{ "foo" , 42 }};

    m_address.setCity("Madrid");

    m_address.setCountry("Spain");

    m_address.setCountryCode("SPA");

    m_coordinate.setLatitude(21.3434);

    m_coordinate.setLongitude(38.43443);

    m_coordinate.setAltitude(634.21);

    m_extendedAttributes["foo"] = 43;

    m_location.setAddress(m_address);

    m_location.setCoordinate(m_coordinate);

    m_location.setExtendedAttributes(m_extendedAttributes);

    //Create a copy and see that they are the same

    QGeoLocation qgeolocationcopy(m_location);

    QVERIFY(m_location == qgeolocationcopy);

    QVERIFY(!(m_location != qgeolocationcopy));

    //Modify one and test if they are different

   qgeolocationcopy.setAddress(qgeoaddresscopy);

   QVERIFY(!(m_location == qgeolocationcopy));

   QVERIFY(m_location != qgeolocationcopy);

   qgeolocationcopy.setAddress(m_address);

   qgeolocationcopy.setCoordinate(qgeocoordinatecopy);

   QVERIFY(!(m_location == qgeolocationcopy));

   QVERIFY(m_location != qgeolocationcopy);

   qgeolocationcopy.setCoordinate(m_coordinate);

   qgeolocationcopy.setExtendedAttributes(extendedAttributesCopy);

   QVERIFY(!(m_location == qgeolocationcopy));

   QVERIFY(m_location != qgeolocationcopy);

    //delete qgeolocationcopy;

    //Asign and test that they are the same

    qgeolocationcopy = m_location;

    QVERIFY(m_location ==qgeolocationcopy);

    QVERIFY(!(m_location != qgeolocationcopy));

void tst_QGeoLocation::comparison()

    QFETCH(QString, dataField);

    QGeoLocation location;

    //set address

    QGeoAddress address;

    address.setStreet("21 jump st");

    address.setCountry("USA");

    location.setAddress(address);

    //set coordinate

    location.setCoordinate(QGeoCoordinate(5,10));

    //set viewport

    location.setBoundingShape(QGeoRectangle(QGeoCoordinate(5,5),0.4,0.4));

    QGeoLocation otherLocation(location);

    if (dataField == "no change") {

        QCOMPARE(location, otherLocation);

    } else {

        if (dataField == "address") {

            QGeoAddress otherAddress;

            otherAddress.setStreet("42 evergreen tce");

            otherAddress.setCountry("USA");

            otherLocation.setAddress(otherAddress);

        } else if (dataField == "coordinate") {

            otherLocation.setCoordinate(QGeoCoordinate(12,13));

        } else if (dataField == "viewport"){

            otherLocation.setBoundingShape(QGeoRectangle(QGeoCoordinate(1,2), 0.5,0.5));

        } else if (dataField == "extendedAttributes"){

            otherLocation.setExtendedAttributes(QVariantMap({{"foo", 44}}));

        } else {

            qFatal("Unknown data field to test");

        QVERIFY(location != otherLocation);

void tst_QGeoLocation::comparison_data()

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

    QTest::newRow("no change") << "no change";

    QTest::newRow("address") << "address";

    QTest::newRow("coordinate") << "coordinate";

    QTest::newRow("extendedAttributes") << "extendedAttributes";

void tst_QGeoLocation::isEmpty()

    QGeoAddress address;

    address.setCity(QStringLiteral("Braunschweig"));

    QVERIFY(!address.isEmpty());

    QGeoRectangle boundingBox;

    boundingBox.setTopLeft(QGeoCoordinate(1, -1));

    boundingBox.setBottomRight(QGeoCoordinate(-1, 1));

    QVERIFY(!boundingBox.isEmpty());

    QVariantMap extendedAttributes({{"foo", 11}});

    QGeoLocation location;

    QVERIFY(location.isEmpty());

    // address

    location.setAddress(address);

    QVERIFY(!location.isEmpty());

    location.setAddress(QGeoAddress());

    QVERIFY(location.isEmpty());

    // coordinate

    location.setCoordinate(QGeoCoordinate(1, 2));

    QVERIFY(!location.isEmpty());

    location.setCoordinate(QGeoCoordinate());

    QVERIFY(location.isEmpty());

    // bounding box

    location.setBoundingShape(boundingBox);

    QVERIFY(!location.isEmpty());

    location.setBoundingShape(QGeoRectangle());

    QVERIFY(location.isEmpty());

    // extended attributes

    location.setExtendedAttributes(extendedAttributes);

    QVERIFY(!location.isEmpty());

    location.setExtendedAttributes(QVariantMap());

    QVERIFY(location.isEmpty());

void tst_QGeoLocation::hashing()

    QFETCH(QGeoLocation, leftLocation);

    QFETCH(QGeoLocation, rightLocation);

    QFETCH(bool, result);

    const size_t leftHash = qHash(leftLocation);

    const size_t rightHash = qHash(rightLocation);

    QCOMPARE(leftHash == rightHash, result);

void tst_QGeoLocation::hashing_data()

    QTest::addColumn<QGeoLocation>("leftLocation");

    QTest::addColumn<QGeoLocation>("rightLocation");

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

    QTest::newRow("empty") << QGeoLocation() << QGeoLocation() << true;

    QGeoAddress address;

    address.setCity("city");

    address.setPostalCode("1234");

    address.setDistrict("district");

    address.setStreet("street");

    address.setStreetNumber("12");

    QGeoLocation leftLocation;

    leftLocation.setAddress(address);

    leftLocation.setCoordinate(QGeoCoordinate(1, 1));

    leftLocation.setBoundingShape(QGeoCircle(QGeoCoordinate(1, 1), 10));

    // do not copy, so that they have different d_ptr's

    QGeoLocation rightLocation;

    rightLocation.setAddress(address);

    rightLocation.setCoordinate(QGeoCoordinate(1, 1));

    rightLocation.setBoundingShape(QGeoCircle(QGeoCoordinate(1, 1), 10));

    QTest::newRow("same locations") << leftLocation << rightLocation << true;

    QGeoLocation rightLocationCopy = rightLocation;

    rightLocationCopy.setBoundingShape(QGeoRectangle(QGeoCoordinate(2, 0), QGeoCoordinate(0, 2)));

    QTest::newRow("different shapes") << leftLocation << rightLocationCopy << false;

    rightLocationCopy = rightLocation;

    rightLocationCopy.setCoordinate(QGeoCoordinate(2, 1));

    QTest::newRow("different coordinates") << leftLocation << rightLocationCopy << false;

    rightLocationCopy = rightLocation;

    address.setState("state");

    rightLocationCopy.setAddress(address);

    QTest::newRow("different addresses") << leftLocation << rightLocationCopy << false;

QTEST_APPLESS_MAIN(tst_QGeoLocation);