qt-everywhere-src-5.14.1/qtlocation/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <QtCore/QString>
#include <QtTest/QtTest>

#include <QtLocation/private/qgeocameracapabilities_p.h>
#include <QtLocation/private/qgeotiledmap_p.h>

QT_USE_NAMESPACE

class tst_QGeoCameraCapabilities : public QObject
{
    Q_OBJECT

public:
    tst_QGeoCameraCapabilities();

private:
    void populateGeoCameraCapabilitiesData();

private Q_SLOTS:
    void constructorTest_data();
    void constructorTest();
    void minimumZoomLevelTest();
    void maximumZoomLevelTest();
    void supportsBearingTest();
    void supportsRollingTest();
    void supportsTiltingTest();
    void minimumTiltTest();
    void maximumTiltTest();
    void minimumFieldOfViewTest();
    void maximumFieldOfViewTest();
    void operatorsTest_data();
    void operatorsTest();
    void isValidTest();
};

tst_QGeoCameraCapabilities::tst_QGeoCameraCapabilities()
{
}

void tst_QGeoCameraCapabilities::populateGeoCameraCapabilitiesData(){
    QTest::addColumn<double>("minimumZoomLevel");
    QTest::addColumn<double>("maximumZoomLevel");
    QTest::addColumn<double>("minimumTilt");
    QTest::addColumn<double>("maximumTilt");
    QTest::addColumn<double>("minimumFieldOfView");
    QTest::addColumn<double>("maximumFieldOfView");
    QTest::addColumn<bool>("bearingSupport");
    QTest::addColumn<bool>("rollingSupport");
    QTest::addColumn<bool>("tiltingSupport");
    QTest::newRow("zeros") << 0.0 << 0.0 << 0.0 << 0.0 << 0.0 << 0.0 << false << false << false;
    QTest::newRow("valid") << 1.0 << 2.0 << 0.5 << 1.5 << 1.0 << 179.0 << true << true << true;
    QTest::newRow("negative values") << 0.0 << 0.5 << -0.5 << -0.1 << -20.0 << -30.0 << true << true << true;
}

void tst_QGeoCameraCapabilities::constructorTest_data(){
    populateGeoCameraCapabilitiesData();
}

void tst_QGeoCameraCapabilities::constructorTest()
{
    QFETCH(double, minimumZoomLevel);
    QFETCH(double, maximumZoomLevel);
    QFETCH(double, minimumTilt);
    QFETCH(double, maximumTilt);
    QFETCH(double, minimumFieldOfView);
    QFETCH(double, maximumFieldOfView);
    QFETCH(bool, bearingSupport);
    QFETCH(bool, rollingSupport);
    QFETCH(bool, tiltingSupport);

    minimumFieldOfView = qBound(1.0, minimumFieldOfView, 179.0);
    maximumFieldOfView = qBound(1.0, maximumFieldOfView, 179.0);

    // contructor test with default values
    QGeoCameraCapabilities cameraCapabilities;
    QGeoCameraCapabilities cameraCapabilities2(cameraCapabilities);
    QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities2.minimumZoomLevel());
    QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities2.maximumZoomLevel());
    QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Copy constructor failed for bearing support");
    QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Copy constructor failed for rolling support ");
    QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Copy constructor failed for tilting support");
    QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt());
    QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt());
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities2.minimumFieldOfView());
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities2.maximumFieldOfView());

    // constructor test after setting values
    cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel);
    cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel);
    cameraCapabilities.setMinimumTilt(minimumTilt);
    cameraCapabilities.setMaximumTilt(maximumTilt);
    cameraCapabilities.setMinimumFieldOfView(minimumFieldOfView);
    cameraCapabilities.setMaximumFieldOfView(maximumFieldOfView);
    cameraCapabilities.setSupportsBearing(bearingSupport);
    cameraCapabilities.setSupportsRolling(rollingSupport);
    cameraCapabilities.setSupportsTilting(tiltingSupport);

    QGeoCameraCapabilities cameraCapabilities3(cameraCapabilities);
    // test the correctness of the constructor copy
    QCOMPARE(cameraCapabilities3.minimumZoomLevel(), minimumZoomLevel);
    QCOMPARE(cameraCapabilities3.maximumZoomLevel(), maximumZoomLevel);
    QCOMPARE(cameraCapabilities3.minimumTilt(), minimumTilt);
    QCOMPARE(cameraCapabilities3.maximumTilt(), maximumTilt);
    QCOMPARE(cameraCapabilities3.minimumFieldOfView(), minimumFieldOfView);
    QCOMPARE(cameraCapabilities3.maximumFieldOfView(), maximumFieldOfView);
    QVERIFY2(cameraCapabilities3.supportsBearing() == bearingSupport, "Copy constructor failed for bearing support");
    QVERIFY2(cameraCapabilities3.supportsRolling() == rollingSupport, "Copy constructor failed for rolling support ");
    QVERIFY2(cameraCapabilities3.supportsTilting() == tiltingSupport, "Copy constructor failed for tilting support");
    // verify that values have not changed after a constructor copy
    QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities3.minimumZoomLevel());
    QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities3.maximumZoomLevel());
    QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities3.supportsBearing(), "Copy constructor failed for bearing support");
    QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities3.supportsRolling(), "Copy constructor failed for rolling support ");
    QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities3.supportsTilting(), "Copy constructor failed for tilting support");
    QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities3.minimumTilt());
    QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities3.maximumTilt());
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities3.minimumFieldOfView());
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities3.maximumFieldOfView());
}

void tst_QGeoCameraCapabilities::minimumZoomLevelTest()
{
    QGeoCameraCapabilities cameraCapabilities;
    cameraCapabilities.setMinimumZoomLevel(1.5);
    QCOMPARE(cameraCapabilities.minimumZoomLevel(), 1.5);

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QCOMPARE(cameraCapabilities2.minimumZoomLevel(), 1.5);
    cameraCapabilities.setMinimumZoomLevel(2.5);
    QCOMPARE(cameraCapabilities2.minimumZoomLevel(), 1.5);
}

void tst_QGeoCameraCapabilities::maximumZoomLevelTest()
{
    QGeoCameraCapabilities cameraCapabilities;
    cameraCapabilities.setMaximumZoomLevel(3.5);
    QCOMPARE(cameraCapabilities.maximumZoomLevel(), 3.5);

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QCOMPARE(cameraCapabilities2.maximumZoomLevel(), 3.5);
    cameraCapabilities.setMaximumZoomLevel(4.5);
    QCOMPARE(cameraCapabilities2.maximumZoomLevel(), 3.5);
}

void tst_QGeoCameraCapabilities::supportsBearingTest(){
    QGeoCameraCapabilities cameraCapabilities;
    QVERIFY(!cameraCapabilities.supportsBearing());
    cameraCapabilities.setSupportsBearing(true);
    QVERIFY2(cameraCapabilities.supportsBearing(), "Camera capabilities should support bearing");

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QVERIFY(cameraCapabilities2.supportsBearing());
    cameraCapabilities.setSupportsBearing(false);
    QVERIFY2(cameraCapabilities2.supportsBearing(), "Camera capabilities should support bearing");
}

void tst_QGeoCameraCapabilities::supportsRollingTest(){
    QGeoCameraCapabilities cameraCapabilities;
    QVERIFY(!cameraCapabilities.supportsRolling());
    cameraCapabilities.setSupportsRolling(true);
    QVERIFY2(cameraCapabilities.supportsRolling(), "Camera capabilities should support rolling");

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QVERIFY(cameraCapabilities2.supportsRolling());
    cameraCapabilities.setSupportsRolling(false);
    QVERIFY2(cameraCapabilities2.supportsRolling(), "Camera capabilities should support rolling");
}

void tst_QGeoCameraCapabilities::supportsTiltingTest(){
    QGeoCameraCapabilities cameraCapabilities;
    QVERIFY(!cameraCapabilities.supportsTilting());
    cameraCapabilities.setSupportsTilting(true);
    QVERIFY2(cameraCapabilities.supportsTilting(), "Camera capabilities should support tilting");

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QVERIFY(cameraCapabilities2.supportsTilting());
    cameraCapabilities.setSupportsTilting(false);
    QVERIFY2(cameraCapabilities2.supportsTilting(), "Camera capabilities should support tilting");
}

void tst_QGeoCameraCapabilities::minimumTiltTest(){
    QGeoCameraCapabilities cameraCapabilities;
    QCOMPARE(cameraCapabilities.minimumTilt(),0.0);
    cameraCapabilities.setMinimumTilt(0.5);
    QCOMPARE(cameraCapabilities.minimumTilt(),0.5);

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QCOMPARE(cameraCapabilities2.minimumTilt(), 0.5);
    cameraCapabilities.setMinimumTilt(1.5);
    QCOMPARE(cameraCapabilities2.minimumTilt(), 0.5);
}

void tst_QGeoCameraCapabilities::maximumTiltTest(){
    QGeoCameraCapabilities cameraCapabilities;
    QCOMPARE(cameraCapabilities.maximumTilt(),0.0);
    cameraCapabilities.setMaximumTilt(1.5);
    QCOMPARE(cameraCapabilities.maximumTilt(),1.5);

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QCOMPARE(cameraCapabilities2.maximumTilt(), 1.5);
    cameraCapabilities.setMaximumTilt(2.5);
    QCOMPARE(cameraCapabilities2.maximumTilt(), 1.5);
}

void tst_QGeoCameraCapabilities::minimumFieldOfViewTest()
{
    QGeoCameraCapabilities cameraCapabilities;
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 45.0); // min/max default to 45
    cameraCapabilities.setMinimumFieldOfView(1.5);
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 1.5);
    cameraCapabilities.setMinimumFieldOfView(-1.5);
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 1.0);
    cameraCapabilities.setMinimumFieldOfView(245.5);
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), 179.0);

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QCOMPARE(cameraCapabilities2.minimumFieldOfView(), 179.0);
    cameraCapabilities.setMinimumFieldOfView(2.5);
    QCOMPARE(cameraCapabilities2.minimumFieldOfView(), 179.0);
}

void tst_QGeoCameraCapabilities::maximumFieldOfViewTest()
{
    QGeoCameraCapabilities cameraCapabilities;
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 45.0); // min/max default to 45
    cameraCapabilities.setMaximumFieldOfView(1.5);
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 1.5);
    cameraCapabilities.setMaximumFieldOfView(-1.5);
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 1.0);
    cameraCapabilities.setMaximumFieldOfView(245.5);
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), 179.0);

    QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities;
    QCOMPARE(cameraCapabilities2.maximumFieldOfView(), 179.0);
    cameraCapabilities.setMaximumFieldOfView(2.5);
    QCOMPARE(cameraCapabilities2.maximumFieldOfView(), 179.0);
}

void tst_QGeoCameraCapabilities::operatorsTest_data(){
    populateGeoCameraCapabilitiesData();
}

void tst_QGeoCameraCapabilities::operatorsTest(){

    QFETCH(double, minimumZoomLevel);
    QFETCH(double, maximumZoomLevel);
    QFETCH(double, minimumTilt);
    QFETCH(double, maximumTilt);
    QFETCH(double, minimumFieldOfView);
    QFETCH(double, maximumFieldOfView);
    QFETCH(bool, bearingSupport);
    QFETCH(bool, rollingSupport);
    QFETCH(bool, tiltingSupport);

    minimumFieldOfView = qBound(1.0, minimumFieldOfView, 179.0);
    maximumFieldOfView = qBound(1.0, maximumFieldOfView, 179.0);

    QGeoCameraCapabilities cameraCapabilities;
    cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel);
    cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel);
    cameraCapabilities.setMinimumTilt(minimumTilt);
    cameraCapabilities.setMaximumTilt(maximumTilt);
    cameraCapabilities.setMinimumFieldOfView(minimumFieldOfView);
    cameraCapabilities.setMaximumFieldOfView(maximumFieldOfView);
    cameraCapabilities.setSupportsBearing(bearingSupport);
    cameraCapabilities.setSupportsRolling(rollingSupport);
    cameraCapabilities.setSupportsTilting(tiltingSupport);
    QGeoCameraCapabilities cameraCapabilities2;
    cameraCapabilities2 = cameraCapabilities;
    // test the correctness of the assignment
    QCOMPARE(cameraCapabilities2.minimumZoomLevel(), minimumZoomLevel);
    QCOMPARE(cameraCapabilities2.maximumZoomLevel(), maximumZoomLevel);
    QCOMPARE(cameraCapabilities2.minimumTilt(), minimumTilt);
    QCOMPARE(cameraCapabilities2.maximumTilt(), maximumTilt);
    QVERIFY2(cameraCapabilities2.supportsBearing() == bearingSupport, "Assignment operator failed for bearing support");
    QVERIFY2(cameraCapabilities2.supportsRolling() == rollingSupport, "Assignment operator failed for rolling support ");
    QVERIFY2(cameraCapabilities2.supportsTilting() == tiltingSupport, "Assignment operator failed for tilting support");
    QCOMPARE(cameraCapabilities2.minimumFieldOfView(), minimumFieldOfView);
    QCOMPARE(cameraCapabilities2.maximumFieldOfView(), maximumFieldOfView);
    // verify that values have not changed after a constructor copy
    QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities2.minimumZoomLevel());
    QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities2.maximumZoomLevel());
    QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Assignment operator failed for bearing support");
    QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Assignment operator failed for rolling support ");
    QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Assignment operator failed for tilting support");
    QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt());
    QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt());
    QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities2.minimumFieldOfView());
    QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities2.maximumFieldOfView());
}

void tst_QGeoCameraCapabilities::isValidTest(){
    QGeoCameraCapabilities cameraCapabilities;
    QVERIFY2(!cameraCapabilities.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities.setSupportsBearing(true);
    QVERIFY2(cameraCapabilities.isValid(), "Camera capabilities should be valid");

    QGeoCameraCapabilities cameraCapabilities2;
    QVERIFY2(!cameraCapabilities2.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities2.setSupportsRolling(true);
    QVERIFY2(cameraCapabilities2.isValid(), "Camera capabilities should be valid");

    QGeoCameraCapabilities cameraCapabilities3;
    QVERIFY2(!cameraCapabilities3.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities3.setSupportsTilting(true);
    QVERIFY2(cameraCapabilities3.isValid(), "Camera capabilities should be valid");

    QGeoCameraCapabilities cameraCapabilities4;
    QVERIFY2(!cameraCapabilities4.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities4.setMinimumZoomLevel(1.0);
    QVERIFY2(cameraCapabilities4.isValid(), "Camera capabilities should be valid");

    QGeoCameraCapabilities cameraCapabilities5;
    QVERIFY2(!cameraCapabilities5.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities5.setMaximumZoomLevel(1.5);
    QVERIFY2(cameraCapabilities5.isValid(), "Camera capabilities should be valid");

    QGeoCameraCapabilities cameraCapabilities6;
    QVERIFY2(!cameraCapabilities6.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities6.setMinimumTilt(0.2);
    QVERIFY2(cameraCapabilities6.isValid(), "Camera capabilities should be valid");

    QGeoCameraCapabilities cameraCapabilities7;
    QVERIFY2(!cameraCapabilities7.isValid(), "Camera capabilities should default to invalid");
    cameraCapabilities7.setMaximumTilt(0.8);
    QVERIFY2(cameraCapabilities7.isValid(), "Camera capabilities should be valid");
}

QTEST_APPLESS_MAIN(tst_QGeoCameraCapabilities)

#include "tst_qgeocameracapabilities.moc"