void tst_QNmeaPositionInfoSource::requestUpdate_after_start()
{
QNmeaPositionInfoSource source(m_mode);
QNmeaPositionInfoSourceProxyFactory factory;
QNmeaPositionInfoSourceProxy *proxy = static_cast<QNmeaPositionInfoSourceProxy*>(factory.createProxy(&source));
QSignalSpy spyUpdate(proxy->source(), SIGNAL(positionUpdated(QGeoPositionInfo)));
QSignalSpy spyTimeout(proxy->source(), SIGNAL(updateTimeout()));
// Start updates with 500ms interval and requestUpdate() with 100ms
// timeout. Feed an update, and it should be emitted immediately due to
// the requestUpdate(). The update should not be emitted again after that
// (i.e. the startUpdates() interval should not cause it to be re-emitted).
QDateTime dt = QDateTime::currentDateTime().toUTC();
proxy->source()->setUpdateInterval(500);
proxy->source()->startUpdates();
proxy->source()->requestUpdate(100);
proxy->feedUpdate(dt);
QTRY_COMPARE(spyUpdate.count(), 1);
QCOMPARE(spyUpdate[0][0].value<QGeoPositionInfo>().timestamp(), dt);
QCOMPARE(spyTimeout.count(), 0);
spyUpdate.clear();
// Update has been emitted for requestUpdate(), shouldn't be emitted for startUpdates()
QTRY_COMPARE_WITH_TIMEOUT(spyUpdate.count(), 0, 1000);
}
//TC_ID_3_x_1
void TestQGeoPositionInfoSource::stopUpdates()
{
CHECK_SOURCE_VALID;
#if defined(Q_WS_MAEMO_6) || defined(Q_OS_SYMBIAN)
QSKIP("Real GPS not suitable for autotesting, skipping the test.", SkipAll);
#endif
QSignalSpy spy(m_source, SIGNAL(positionUpdated(const QGeoPositionInfo&)));
QSignalSpy timeout(m_source, SIGNAL(updateTimeout()));
m_source->setUpdateInterval(7000);
m_source->startUpdates();
for (int i = 0; i < 2; i++) {
EXPECT_FAIL_WINCE_SEE_MOBILITY_337;
QTRY_VERIFY_WITH_TIMEOUT((spy.count() > 0) && (timeout.count() == 0), 9500);
spy.clear();
}
m_source->stopUpdates();
QTest::qWait(9500);
QCOMPARE(spy.count(), 0);
spy.clear();
m_source->setUpdateInterval(0);
m_source->startUpdates();
m_source->stopUpdates();
QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 0, 9500);
}
void TestQGeoSatelliteInfoSource::requestUpdate_timeoutLessThanMinimumInterval()
{
CHECK_SOURCE_VALID;
QSignalSpy spyTimeout(m_source, SIGNAL(requestTimeout()));
m_source->requestUpdate(1);
QTRY_COMPARE_WITH_TIMEOUT(spyTimeout.count(), 1, 1000);
}
// TC_ID_3_x_2 : Create position source and call requestUpdate with a timeout less than
// minimumupdateInterval
void TestQGeoPositionInfoSource::requestUpdate_timeoutLessThanMinimumInterval()
{
CHECK_SOURCE_VALID;
QSignalSpy spyTimeout(m_source, SIGNAL(updateTimeout()));
m_source->requestUpdate(1);
EXPECT_FAIL_WINCE_SEE_MOBILITY_337;
QTRY_COMPARE_WITH_TIMEOUT(spyTimeout.count(), 1, 1000);
}
void TestQGeoSatelliteInfoSource::requestUpdate_overlappingCallsWithTimeout()
{
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyTimeout(m_source,
SIGNAL(requestTimeout()));
m_source->requestUpdate(0);
m_source->requestUpdate(1);
QTRY_COMPARE_WITH_TIMEOUT(spyTimeout.count(), 0, 7000);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 1) && (spyUse.count() == 1), 7000);
}
void testQOfonoCellBroadcast()
{
QSignalSpy inBroadcast(m, SIGNAL(incomingBroadcast( QString ,quint16)));
//QSignalSpy emBroadcast(m, SIGNAL(emergencyBroadcast( QString , QVariantMap)));
QSignalSpy topicsSpy(m, SIGNAL(topicsChanged(QString)));
qDebug() << "Please send CBM using phonesim";
//QCOMPARE(emBroadcast.count(), 1);
QTRY_COMPARE_WITH_TIMEOUT(inBroadcast.count(), 1, INTERACTIVE_STEP_TIMEOUT);
QString topicsList = "20,50-51,60";
m->setTopics("");
QTRY_COMPARE(topicsSpy.count(), 1);
QCOMPARE(topicsSpy.takeFirst().at(0).toString(), QString());
m->setTopics(topicsList);
QTRY_COMPARE(topicsSpy.count(), 1);
QCOMPARE(topicsSpy.takeFirst().at(0).toString(), topicsList);
}
void tst_QNmeaPositionInfoSource::beginWithBufferedData()
{
// In SimulationMode, data stored in the QIODevice is read when
// startUpdates() or requestUpdate() is called.
// In RealTimeMode, all existing data in the QIODevice is ignored -
// only new data will be read.
QFETCH(QList<QDateTime>, dateTimes);
QFETCH(UpdateTriggerMethod, trigger);
QByteArray bytes;
for (int i=0; i<dateTimes.count(); i++)
bytes += QLocationTestUtils::createRmcSentence(dateTimes[i]).toLatin1();
QBuffer buffer;
buffer.setData(bytes);
QNmeaPositionInfoSource source(m_mode);
QSignalSpy spy(&source, SIGNAL(positionUpdated(QGeoPositionInfo)));
source.setDevice(&buffer);
if (trigger == StartUpdatesMethod)
source.startUpdates();
else if (trigger == RequestUpdatesMethod)
source.requestUpdate();
if (m_mode == QNmeaPositionInfoSource::RealTimeMode) {
QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 0, 300);
} else {
if (trigger == StartUpdatesMethod) {
QTRY_COMPARE(spy.count(), dateTimes.count());
for (int i=0; i<dateTimes.count(); i++)
QCOMPARE(spy.at(i).at(0).value<QGeoPositionInfo>().timestamp(), dateTimes[i]);
} else if (trigger == RequestUpdatesMethod) {
QTRY_COMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).value<QGeoPositionInfo>().timestamp(), dateTimes.first());
}
}
}
//TC_ID_3_x_1
void TestQGeoPositionInfoSource::startUpdates_testIntervals()
{
CHECK_SOURCE_VALID;
QSignalSpy spy(m_source, SIGNAL(positionUpdated(const QGeoPositionInfo&)));
QSignalSpy timeout(m_source, SIGNAL(updateTimeout()));
m_source->setUpdateInterval(7000);
int interval = m_source->updateInterval();
m_source->startUpdates();
EXPECT_FAIL_WINCE_SEE_MOBILITY_337;
QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 9500);
for (int i = 0; i < 6; i++) {
EXPECT_FAIL_WINCE_SEE_MOBILITY_337;
QTRY_VERIFY_WITH_TIMEOUT((spy.count() == 1) && (timeout.count() == 0), (interval*2));
spy.clear();
}
m_source->stopUpdates();
}
void LocalQmlProfilerRunnerTest::testRunner()
{
Debugger::AnalyzerConnection connection;
LocalQmlProfilerRunner::Configuration configuration;
configuration.debuggee.executable = "\\-/|\\-/";
configuration.debuggee.environment = Utils::Environment::systemEnvironment();
// should not be used anywhere but cannot be empty
configuration.socket = connection.analyzerSocket = QString("invalid");
Debugger::AnalyzerRunControl *rc = Debugger::createAnalyzerRunControl(
nullptr, ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
rc->setConnection(connection);
auto runner = new LocalQmlProfilerRunner(configuration, rc);
bool running = false;
int runCount = 0;
auto connectRunner = [&]() {
connect(runner, &LocalQmlProfilerRunner::started, this, [&running, &runCount](){
QVERIFY(!running);
++runCount;
running = true;
});
connect(runner, &LocalQmlProfilerRunner::stopped, this, [&running](){
QVERIFY(running);
running = false;
});
};
connectRunner();
rc->start();
QTRY_COMPARE_WITH_TIMEOUT(runCount, 1, 10000);
QTRY_VERIFY_WITH_TIMEOUT(!running, 10000);
configuration.socket = connection.analyzerSocket = LocalQmlProfilerRunner::findFreeSocket();
configuration.debuggee.executable = qApp->applicationFilePath();
// comma is used to specify a test function. In this case, an invalid one.
configuration.debuggee.commandLineArguments = QString("-test QmlProfiler,");
delete rc;
rc = Debugger::createAnalyzerRunControl(
nullptr, ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
rc->setConnection(connection);
runner = new LocalQmlProfilerRunner(configuration, rc);
connectRunner();
rc->start();
QTRY_COMPARE_WITH_TIMEOUT(runCount, 2, 10000);
QTRY_VERIFY_WITH_TIMEOUT(!running, 10000);
delete rc;
configuration.debuggee.commandLineArguments.clear();
configuration.socket.clear();
connection.analyzerSocket.clear();
configuration.port = connection.analyzerPort =
LocalQmlProfilerRunner::findFreePort(connection.analyzerHost);
rc = Debugger::createAnalyzerRunControl(
nullptr, ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
rc->setConnection(connection);
runner = new LocalQmlProfilerRunner(configuration, rc);
connectRunner();
rc->start();
QTRY_COMPARE_WITH_TIMEOUT(runCount, 3, 10000);
rc->stop();
QTRY_VERIFY_WITH_TIMEOUT(!running, 10000);
delete rc;
}
void TestQGeoPositionInfoSource::updateInferno()
{
// Tests different position update failure scenarios
// Successful, normal update
m_source->setUpdateInterval(1000);
QSignalSpy updateSpy(m_source, SIGNAL(positionUpdated(const QGeoPositionInfo&)));
QSignalSpy timeoutSpy(m_source, SIGNAL(updateTimeout()));
m_source->startUpdates();
QTRY_VERIFY_WITH_TIMEOUT(!updateSpy.isEmpty(), 2100);
QVERIFY(timeoutSpy.isEmpty());
// Suppress the regular updates and check that timeouts are received
// Then resume the updates and see it goes ok.
geocluemock_set_suppress_regular_updates(true);
updateSpy.clear(); timeoutSpy.clear();
QTest::qWait(2000);
// there is no updateTimeout because there is no error
QTRY_VERIFY_WITH_TIMEOUT(timeoutSpy.isEmpty(), 2000);
QVERIFY(updateSpy.isEmpty());
geocluemock_set_suppress_regular_updates(false);
QTRY_VERIFY_WITH_TIMEOUT(!updateSpy.isEmpty(), 4000);
QVERIFY(timeoutSpy.isEmpty());
// Restart updates and check velocity is received when expected
m_source->stopUpdates();
updateSpy.clear(); timeoutSpy.clear();
// start updates without velocity
geocluemock_set_suppress_velocity_update(true);
m_source->startUpdates();
QTRY_VERIFY_WITH_TIMEOUT(!updateSpy.isEmpty(), 4000);
QGeoPositionInfo info = updateSpy.takeFirst().at(0).value<QGeoPositionInfo>();
QVERIFY(info.isValid());
QVERIFY(!info.hasAttribute(QGeoPositionInfo::GroundSpeed));
// enable velocity updates again
geocluemock_set_suppress_velocity_update(false);
updateSpy.clear(); timeoutSpy.clear();
QTest::qWait(3000);
QTRY_VERIFY_WITH_TIMEOUT(!updateSpy.isEmpty(), 4000);
info = updateSpy.takeLast().at(0).value<QGeoPositionInfo>();
QVERIFY(info.isValid());
QVERIFY(info.hasAttribute(QGeoPositionInfo::GroundSpeed));
m_source->stopUpdates();
// Test that bad updatedata produces timeout both on regular updates
// and single updates
geocluemock_set_position_fields(0);
updateSpy.clear(); timeoutSpy.clear();
m_source->startUpdates();
QTRY_VERIFY_WITH_TIMEOUT(!timeoutSpy.isEmpty(), 2000);
QVERIFY(updateSpy.isEmpty());
updateSpy.clear(); timeoutSpy.clear();
m_source->requestUpdate(1000);
QTRY_VERIFY_WITH_TIMEOUT(!timeoutSpy.isEmpty(), 2000);
QVERIFY(updateSpy.isEmpty());
geocluemock_unset_position_fields(); // clear
// Test that lib works ok with instane lat/lon values
geocluemock_set_position_latitude(1000);
updateSpy.clear(); timeoutSpy.clear();
QTRY_VERIFY_WITH_TIMEOUT(!updateSpy.isEmpty(), 2000);
QVERIFY(timeoutSpy.isEmpty());
info = updateSpy.takeLast().at(0).value<QGeoPositionInfo>();
QVERIFY(!info.isValid());
geocluemock_unset_position_latitude(); // clear
// Test that invalid velocity updates are not emitted
geocluemock_set_velocity_fields(0);
updateSpy.clear(); timeoutSpy.clear();
QTest::qWait(1500);
QTRY_VERIFY_WITH_TIMEOUT(!updateSpy.isEmpty(), 2000);
QVERIFY(timeoutSpy.isEmpty());
info = updateSpy.takeLast().at(0).value<QGeoPositionInfo>();
QVERIFY(info.isValid());
QVERIFY(!info.hasAttribute(QGeoPositionInfo::GroundSpeed));
geocluemock_unset_velocity_fields();
// Test that requestUpdate timeouts correctly
geocluemock_set_suppress_single_update(true);
geocluemock_set_suppress_regular_updates(true);
m_source->stopUpdates();
updateSpy.clear(); timeoutSpy.clear();
m_source->requestUpdate(2000);
QTRY_COMPARE_WITH_TIMEOUT(timeoutSpy.count(), 1, 2100);
QVERIFY(updateSpy.isEmpty());
geocluemock_set_suppress_single_update(false);
geocluemock_set_suppress_regular_updates(false);
// Test changing interval during active updates works ok
m_source->setUpdateInterval(1000);
updateSpy.clear(); timeoutSpy.clear();
m_source->startUpdates();
QTRY_COMPARE_WITH_TIMEOUT_RANGE(updateSpy.count(), 1, 950, 1050);
updateSpy.clear();
m_source->setUpdateInterval(2000);
QTRY_COMPARE_WITH_TIMEOUT_RANGE(updateSpy.count(), 1, 1900, 2100);
// Check that unusual
}
void LocalQmlProfilerRunnerTest::testRunner()
{
QmlProfilerTool tool;
QPointer<ProjectExplorer::RunControl> runControl;
QPointer<LocalQmlProfilerSupport> profiler;
ProjectExplorer::StandardRunnable debuggee;
QUrl serverUrl;
bool running = false;
bool started = false;
int startCount = 0;
int runCount = 0;
int stopCount = 0;
debuggee.executable = "\\-/|\\-/";
debuggee.environment = Utils::Environment::systemEnvironment();
// should not be used anywhere but cannot be empty
serverUrl.setScheme(Utils::urlSocketScheme());
serverUrl.setPath("invalid");
runControl = new ProjectExplorer::RunControl(nullptr,
ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
runControl->setRunnable(debuggee);
profiler = new LocalQmlProfilerSupport(&tool, runControl, serverUrl);
auto connectRunner = [&]() {
connect(runControl, &ProjectExplorer::RunControl::aboutToStart, this, [&]() {
QVERIFY(!started);
QVERIFY(!running);
++startCount;
started = true;
});
connect(runControl, &ProjectExplorer::RunControl::started, this, [&]() {
QVERIFY(started);
QVERIFY(!running);
++runCount;
running = true;
});
connect(runControl, &ProjectExplorer::RunControl::stopped, this, [&]() {
QVERIFY(started);
++stopCount;
running = false;
started = false;
});
connect(runControl, &ProjectExplorer::RunControl::finished, this, [&]() {
running = false;
started = false;
});
};
connectRunner();
runControl->initiateStart();
QTRY_COMPARE_WITH_TIMEOUT(startCount, 1, 30000);
QTRY_VERIFY_WITH_TIMEOUT(!started, 30000);
QCOMPARE(stopCount, 1);
QCOMPARE(runCount, 0);
runControl->initiateFinish();
QTRY_VERIFY(runControl.isNull());
QVERIFY(profiler.isNull());
serverUrl = Utils::urlFromLocalSocket();
debuggee.executable = qApp->applicationFilePath();
// comma is used to specify a test function. In this case, an invalid one.
debuggee.commandLineArguments = QString("-test QmlProfiler,");
runControl = new ProjectExplorer::RunControl(nullptr,
ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
runControl->setRunnable(debuggee);
profiler = new LocalQmlProfilerSupport(&tool, runControl, serverUrl);
connectRunner();
runControl->initiateStart();
QTRY_VERIFY_WITH_TIMEOUT(running, 30000);
QTRY_VERIFY_WITH_TIMEOUT(!running, 30000);
QCOMPARE(startCount, 2);
QCOMPARE(stopCount, 2);
QCOMPARE(runCount, 1);
runControl->initiateFinish();
QTRY_VERIFY(runControl.isNull());
QVERIFY(profiler.isNull());
debuggee.commandLineArguments.clear();
serverUrl.clear();
serverUrl = Utils::urlFromLocalHostAndFreePort();
runControl = new ProjectExplorer::RunControl(nullptr,
ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
runControl->setRunnable(debuggee);
profiler = new LocalQmlProfilerSupport(&tool, runControl, serverUrl);
connectRunner();
runControl->initiateStart();
QTRY_VERIFY_WITH_TIMEOUT(running, 30000);
runControl->initiateStop();
QTRY_VERIFY_WITH_TIMEOUT(!running, 30000);
QCOMPARE(startCount, 3);
QCOMPARE(stopCount, 3);
QCOMPARE(runCount, 2);
runControl->initiateFinish();
QTRY_VERIFY(runControl.isNull());
QVERIFY(profiler.isNull());
debuggee.commandLineArguments = QString("-test QmlProfiler,");
serverUrl.setScheme(Utils::urlSocketScheme());
{
Utils::TemporaryFile file("file with spaces");
if (file.open())
serverUrl.setPath(file.fileName());
}
runControl = new ProjectExplorer::RunControl(nullptr,
ProjectExplorer::Constants::QML_PROFILER_RUN_MODE);
runControl->setRunnable(debuggee);
profiler = new LocalQmlProfilerSupport(&tool, runControl, serverUrl);
connectRunner();
runControl->initiateStart();
QTRY_VERIFY_WITH_TIMEOUT(running, 30000);
QTRY_VERIFY_WITH_TIMEOUT(!running, 30000);
QCOMPARE(startCount, 4);
QCOMPARE(stopCount, 4);
QCOMPARE(runCount, 3);
runControl->initiateFinish();
QTRY_VERIFY(runControl.isNull());
QVERIFY(profiler.isNull());
}
