qt-everywhere-src-5.15.1/qtlocation/tests/auto/qplacemanager/tst_qplacemanager.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** 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/QMetaType>
 #include <QString>
 #include <QtTest/QtTest>

 #include <qgeoserviceprovider.h>
 #include <qplacemanager.h>


 #ifndef WAIT_UNTIL
 #define WAIT_UNTIL(__expr) \
         do { \
         const int __step = 50; \
         const int __timeout = 5000; \
         if (!(__expr)) { \
             QTest::qWait(0); \
         } \
         for (int __i = 0; __i < __timeout && !(__expr); __i+=__step) { \
             QTest::qWait(__step); \
         } \
     } while (0)
 #endif

 QT_USE_NAMESPACE

 class tst_QPlaceManager : public QObject
 {
     Q_OBJECT

 private Q_SLOTS:
     void initTestCase();
     void cleanupTestCase();

     void compatiblePlace();
     void testMetadata();
     void testLocales();
     void testMatchUnsupported();

 private:
     bool checkSignals(QPlaceReply *reply, QPlaceReply::Error expectedError);

     QGeoServiceProvider *provider;
     QPlaceManager *placeManager;
 };

 void tst_QPlaceManager::initTestCase()
 {
 #if QT_CONFIG(library)
     /*
      * Set custom path since CI doesn't install test plugins
      */
 #ifdef Q_OS_WIN
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath() +
                                      QStringLiteral("/../../../../plugins"));
 #else
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath()
                                      + QStringLiteral("/../../../plugins"));
 #endif
 #endif
     provider = 0;

     QStringList providers = QGeoServiceProvider::availableServiceProviders();
     QVERIFY(providers.contains("qmlgeo.test.plugin"));

     provider = new QGeoServiceProvider("qmlgeo.test.plugin");
     provider->setAllowExperimental(true);
     QCOMPARE(provider->placesFeatures() & QGeoServiceProvider::OfflinePlacesFeature,
              QGeoServiceProvider::OfflinePlacesFeature);
     placeManager = provider->placeManager();
     QVERIFY(placeManager);
 }

 void tst_QPlaceManager::testMetadata()
 {
     QCOMPARE(placeManager->managerName(), QStringLiteral("qmlgeo.test.plugin"));
     QCOMPARE(placeManager->managerVersion(), 100);
 }

 void tst_QPlaceManager::testLocales()
 {
     QCOMPARE(placeManager->locales().count(), 1);
     QCOMPARE(placeManager->locales().at(0), QLocale());

     QLocale locale(QLocale::Norwegian, QLocale::Norway);
     placeManager->setLocale(locale);

     QCOMPARE(placeManager->locales().at(0), locale);

     QList<QLocale> locales;
     QLocale en_AU = QLocale(QLocale::English, QLocale::Australia);
     QLocale en_UK = QLocale(QLocale::English, QLocale::UnitedKingdom);
     locales << en_AU << en_UK;
     placeManager->setLocales(locales);
     QCOMPARE(placeManager->locales().count(), 2);
     QCOMPARE(placeManager->locales().at(0), en_AU);
     QCOMPARE(placeManager->locales().at(1), en_UK);
 }

 void tst_QPlaceManager::testMatchUnsupported()
 {
     QPlaceMatchRequest request;
     QPlaceMatchReply *reply = placeManager->matchingPlaces(request);
     QVERIFY(checkSignals(reply, QPlaceReply::UnsupportedError));
 }

 void tst_QPlaceManager::compatiblePlace()
 {
     QPlace place;
     place.setPlaceId(QStringLiteral("4-8-15-16-23-42"));
     place.setName(QStringLiteral("Island"));
     place.setVisibility(QLocation::PublicVisibility);

     QPlace compatPlace = placeManager->compatiblePlace(place);
     QVERIFY(compatPlace.placeId().isEmpty());
     QCOMPARE(compatPlace.name(), QStringLiteral("Island"));
     QCOMPARE(compatPlace.visibility(), QLocation::UnspecifiedVisibility);
 }

 void tst_QPlaceManager::cleanupTestCase()
 {
     delete provider;
 }

 bool tst_QPlaceManager::checkSignals(QPlaceReply *reply, QPlaceReply::Error expectedError)
 {
     QSignalSpy finishedSpy(reply, SIGNAL(finished()));
     QSignalSpy errorSpy(reply, SIGNAL(error(QPlaceReply::Error,QString)));
     QSignalSpy managerFinishedSpy(placeManager, SIGNAL(finished(QPlaceReply*)));
     QSignalSpy managerErrorSpy(placeManager,SIGNAL(error(QPlaceReply*,QPlaceReply::Error,QString)));

     if (expectedError != QPlaceReply::NoError) {
         //check that we get an error signal from the reply
         WAIT_UNTIL(errorSpy.count() == 1);
         if (errorSpy.count() != 1) {
             qWarning() << "Error signal for search operation not received";
             return false;
         }

         //check that we get the correct error from the reply's signal
         QPlaceReply::Error actualError = qvariant_cast<QPlaceReply::Error>(errorSpy.at(0).at(0));
         if (actualError != expectedError) {
             qWarning() << "Actual error code in reply signal does not match expected error code";
             qWarning() << "Actual error code = " << actualError;
             qWarning() << "Expected error coe =" << expectedError;
             return false;
         }

         //check that we get an error  signal from the manager
         WAIT_UNTIL(managerErrorSpy.count() == 1);
         if (managerErrorSpy.count() !=1) {
            qWarning() << "Error signal from manager for search operation not received";
            return false;
         }

         //check that we get the correct reply instance in the error signal from the manager
         if (qvariant_cast<QPlaceReply*>(managerErrorSpy.at(0).at(0)) != reply)  {
             qWarning() << "Reply instance in error signal from manager is incorrect";
             return false;
         }

         //check that we get the correct error from the signal of the manager
         actualError = qvariant_cast<QPlaceReply::Error>(managerErrorSpy.at(0).at(1));
         if (actualError != expectedError) {
             qWarning() << "Actual error code from manager signal does not match expected error code";
             qWarning() << "Actual error code =" << actualError;
             qWarning() << "Expected error code = " << expectedError;
             return false;
         }
     }

     //check that we get a finished signal
     WAIT_UNTIL(finishedSpy.count() == 1);
     if (finishedSpy.count() !=1) {
         qWarning() << "Finished signal from reply not received";
         return false;
     }

     if (reply->error() != expectedError) {
         qWarning() << "Actual error code does not match expected error code";
         qWarning() << "Actual error code: " << reply->error();
         qWarning() << "Expected error code" << expectedError;
         return false;
     }

     if (expectedError == QPlaceReply::NoError && !reply->errorString().isEmpty()) {
         qWarning() << "Expected error was no error but error string was not empty";
         qWarning() << "Error string=" << reply->errorString();
         return false;
     }

     //check that we get the finished signal from the manager
     WAIT_UNTIL(managerFinishedSpy.count() == 1);
     if (managerFinishedSpy.count() != 1) {
         qWarning() << "Finished signal from manager not received";
         return false;
     }

     //check that the reply instance in the finished signal from the manager is correct
     if (qvariant_cast<QPlaceReply *>(managerFinishedSpy.at(0).at(0)) != reply) {
         qWarning() << "Reply instance in finished signal from manager is incorrect";
         return false;
     }

     return true;
 }

 QTEST_GUILESS_MAIN(tst_QPlaceManager)

 #include "tst_qplacemanager.moc"
	/****************************************************************************
	**
	** 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/QMetaType>
	#include <QString>
	#include <QtTest/QtTest>

	#include <qgeoserviceprovider.h>
	#include <qplacemanager.h>


	#ifndef WAIT_UNTIL
	#define WAIT_UNTIL(__expr) \
	do { \
	const int __step = 50; \
	const int __timeout = 5000; \
	if (!(__expr)) { \
	QTest::qWait(0); \
	} \
	for (int __i = 0; __i < __timeout && !(__expr); __i+=__step) { \
	QTest::qWait(__step); \
	} \
	} while (0)
	#endif

	QT_USE_NAMESPACE

	class tst_QPlaceManager : public QObject
	{
	Q_OBJECT

	private Q_SLOTS:
	void initTestCase();
	void cleanupTestCase();

	void compatiblePlace();
	void testMetadata();
	void testLocales();
	void testMatchUnsupported();

	private:
	bool checkSignals(QPlaceReply *reply, QPlaceReply::Error expectedError);

	QGeoServiceProvider *provider;
	QPlaceManager *placeManager;
	};

	void tst_QPlaceManager::initTestCase()
	{
	#if QT_CONFIG(library)
	/*
	* Set custom path since CI doesn't install test plugins
	*/
	#ifdef Q_OS_WIN
	QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath() +
	QStringLiteral("/../../../../plugins"));
	#else
	QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath()
	+ QStringLiteral("/../../../plugins"));
	#endif
	#endif
	provider = 0;

	QStringList providers = QGeoServiceProvider::availableServiceProviders();
	QVERIFY(providers.contains("qmlgeo.test.plugin"));

	provider = new QGeoServiceProvider("qmlgeo.test.plugin");
	provider->setAllowExperimental(true);
	QCOMPARE(provider->placesFeatures() & QGeoServiceProvider::OfflinePlacesFeature,
	QGeoServiceProvider::OfflinePlacesFeature);
	placeManager = provider->placeManager();
	QVERIFY(placeManager);
	}

	void tst_QPlaceManager::testMetadata()
	{
	QCOMPARE(placeManager->managerName(), QStringLiteral("qmlgeo.test.plugin"));
	QCOMPARE(placeManager->managerVersion(), 100);
	}

	void tst_QPlaceManager::testLocales()
	{
	QCOMPARE(placeManager->locales().count(), 1);
	QCOMPARE(placeManager->locales().at(0), QLocale());

	QLocale locale(QLocale::Norwegian, QLocale::Norway);
	placeManager->setLocale(locale);

	QCOMPARE(placeManager->locales().at(0), locale);

	QList<QLocale> locales;
	QLocale en_AU = QLocale(QLocale::English, QLocale::Australia);
	QLocale en_UK = QLocale(QLocale::English, QLocale::UnitedKingdom);
	locales << en_AU << en_UK;
	placeManager->setLocales(locales);
	QCOMPARE(placeManager->locales().count(), 2);
	QCOMPARE(placeManager->locales().at(0), en_AU);
	QCOMPARE(placeManager->locales().at(1), en_UK);
	}

	void tst_QPlaceManager::testMatchUnsupported()
	{
	QPlaceMatchRequest request;
	QPlaceMatchReply *reply = placeManager->matchingPlaces(request);
	QVERIFY(checkSignals(reply, QPlaceReply::UnsupportedError));
	}

	void tst_QPlaceManager::compatiblePlace()
	{
	QPlace place;
	place.setPlaceId(QStringLiteral("4-8-15-16-23-42"));
	place.setName(QStringLiteral("Island"));
	place.setVisibility(QLocation::PublicVisibility);

	QPlace compatPlace = placeManager->compatiblePlace(place);
	QVERIFY(compatPlace.placeId().isEmpty());
	QCOMPARE(compatPlace.name(), QStringLiteral("Island"));
	QCOMPARE(compatPlace.visibility(), QLocation::UnspecifiedVisibility);
	}

	void tst_QPlaceManager::cleanupTestCase()
	{
	delete provider;
	}

	bool tst_QPlaceManager::checkSignals(QPlaceReply *reply, QPlaceReply::Error expectedError)
	{
	QSignalSpy finishedSpy(reply, SIGNAL(finished()));
	QSignalSpy errorSpy(reply, SIGNAL(error(QPlaceReply::Error,QString)));
	QSignalSpy managerFinishedSpy(placeManager, SIGNAL(finished(QPlaceReply*)));
	QSignalSpy managerErrorSpy(placeManager,SIGNAL(error(QPlaceReply*,QPlaceReply::Error,QString)));

	if (expectedError != QPlaceReply::NoError) {
	//check that we get an error signal from the reply
	WAIT_UNTIL(errorSpy.count() == 1);
	if (errorSpy.count() != 1) {
	qWarning() << "Error signal for search operation not received";
	return false;
	}

	//check that we get the correct error from the reply's signal
	QPlaceReply::Error actualError = qvariant_cast<QPlaceReply::Error>(errorSpy.at(0).at(0));
	if (actualError != expectedError) {
	qWarning() << "Actual error code in reply signal does not match expected error code";
	qWarning() << "Actual error code = " << actualError;
	qWarning() << "Expected error coe =" << expectedError;
	return false;
	}

	//check that we get an error signal from the manager
	WAIT_UNTIL(managerErrorSpy.count() == 1);
	if (managerErrorSpy.count() !=1) {
	qWarning() << "Error signal from manager for search operation not received";
	return false;
	}

	//check that we get the correct reply instance in the error signal from the manager
	if (qvariant_cast<QPlaceReply*>(managerErrorSpy.at(0).at(0)) != reply) {
	qWarning() << "Reply instance in error signal from manager is incorrect";
	return false;
	}

	//check that we get the correct error from the signal of the manager
	actualError = qvariant_cast<QPlaceReply::Error>(managerErrorSpy.at(0).at(1));
	if (actualError != expectedError) {
	qWarning() << "Actual error code from manager signal does not match expected error code";
	qWarning() << "Actual error code =" << actualError;
	qWarning() << "Expected error code = " << expectedError;
	return false;
	}
	}

	//check that we get a finished signal
	WAIT_UNTIL(finishedSpy.count() == 1);
	if (finishedSpy.count() !=1) {
	qWarning() << "Finished signal from reply not received";
	return false;
	}

	if (reply->error() != expectedError) {
	qWarning() << "Actual error code does not match expected error code";
	qWarning() << "Actual error code: " << reply->error();
	qWarning() << "Expected error code" << expectedError;
	return false;
	}

	if (expectedError == QPlaceReply::NoError && !reply->errorString().isEmpty()) {
	qWarning() << "Expected error was no error but error string was not empty";
	qWarning() << "Error string=" << reply->errorString();
	return false;
	}

	//check that we get the finished signal from the manager
	WAIT_UNTIL(managerFinishedSpy.count() == 1);
	if (managerFinishedSpy.count() != 1) {
	qWarning() << "Finished signal from manager not received";
	return false;
	}

	//check that the reply instance in the finished signal from the manager is correct
	if (qvariant_cast<QPlaceReply *>(managerFinishedSpy.at(0).at(0)) != reply) {
	qWarning() << "Reply instance in finished signal from manager is incorrect";
	return false;
	}

	return true;
	}

	QTEST_GUILESS_MAIN(tst_QPlaceManager)

	#include "tst_qplacemanager.moc"