void tst_qdeclarativefontloader::webFont()
{
QString componentStr = "import Qt 4.7\nFontLoader { source: \"http://localhost:14448/tarzeau_ocr_a.ttf\" }";
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
QDeclarativeFontLoader *fontObject = qobject_cast<QDeclarativeFontLoader*>(component.create());
QVERIFY(fontObject != 0);
QVERIFY(fontObject->source() != QUrl(""));
QTRY_COMPARE(fontObject->name(), QString("OCRA"));
QTRY_VERIFY(fontObject->status() == QDeclarativeFontLoader::Ready);
}
void tst_QSampleCache::testNotCachedSample()
{
QSampleCache cache;
QSignalSpy loadingSpy(&cache, SIGNAL(isLoadingChanged()));
QSample* sample = cache.requestSample(QUrl::fromLocalFile(QFINDTESTDATA("testdata/test.wav")));
QVERIFY(sample);
QTRY_COMPARE(loadingSpy.count(), 2);
QTRY_VERIFY(!cache.isLoading());
sample->release();
QVERIFY(!cache.isCached(QUrl::fromLocalFile(QFINDTESTDATA("testdata/test.wav"))));
}
void tst_qdeclarativefontloader::failLocalFont()
{
QString componentStr = "import Qt 4.7\nFontLoader { source: \"" + QUrl::fromLocalFile(SRCDIR "/data/dummy.ttf").toString() + "\" }";
QTest::ignoreMessage(QtWarningMsg, QString("file::2:1: QML FontLoader: Cannot load font: \"" + QUrl::fromLocalFile(SRCDIR "/data/dummy.ttf").toString() + "\"").toUtf8().constData());
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
QDeclarativeFontLoader *fontObject = qobject_cast<QDeclarativeFontLoader*>(component.create());
QVERIFY(fontObject != 0);
QVERIFY(fontObject->source() != QUrl(""));
QTRY_COMPARE(fontObject->name(), QString(""));
QTRY_VERIFY(fontObject->status() == QDeclarativeFontLoader::Error);
}
void tst_qdeclarativefontloader::failWebFont()
{
QString componentStr = "import Qt 4.7\nFontLoader { source: \"http://localhost:14448/nonexist.ttf\" }";
QTest::ignoreMessage(QtWarningMsg, "file::2:1: QML FontLoader: Cannot load font: \"http://localhost:14448/nonexist.ttf\"");
QDeclarativeComponent component(&engine);
component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
QDeclarativeFontLoader *fontObject = qobject_cast<QDeclarativeFontLoader*>(component.create());
QVERIFY(fontObject != 0);
QVERIFY(fontObject->source() != QUrl(""));
QTRY_COMPARE(fontObject->name(), QString(""));
QTRY_VERIFY(fontObject->status() == QDeclarativeFontLoader::Error);
}
void tst_QGuiApplication::focusObject()
{
int argc = 0;
QGuiApplication app(argc, 0);
QObject obj1, obj2, obj3;
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
DummyWindow window1;
window1.resize(windowSize, windowSize);
window1.setTitle(QStringLiteral("focusObject:window1"));
window1.setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
DummyWindow window2;
window2.resize(windowSize, windowSize);
window2.setFramePosition(QPoint(screenGeometry.left() + 2 * spacing + windowSize, screenGeometry.top() + spacing));
window2.setTitle(QStringLiteral("focusObject:window2"));
window1.show();
QSignalSpy spy(&app, SIGNAL(focusObjectChanged(QObject*)));
// verify active window focus propagates to qguiapplication
window1.requestActivate();
QVERIFY(QTest::qWaitForWindowActive(&window1));
QCOMPARE(app.focusWindow(), &window1);
window1.setFocusObject(&obj1);
QCOMPARE(app.focusObject(), &obj1);
QCOMPARE(spy.count(), 1);
spy.clear();
window1.setFocusObject(&obj2);
QCOMPARE(app.focusObject(), &obj2);
QCOMPARE(spy.count(), 1);
spy.clear();
window2.setFocusObject(&obj3);
QCOMPARE(app.focusObject(), &obj2); // not yet changed
window2.show();
QVERIFY(QTest::qWaitForWindowExposed(&window2));
QTRY_COMPARE(app.focusWindow(), &window2);
QCOMPARE(app.focusObject(), &obj3);
QCOMPARE(spy.count(), 1);
// focus change on unfocused window does not show
spy.clear();
window1.setFocusObject(&obj1);
QCOMPARE(spy.count(), 0);
QCOMPARE(app.focusObject(), &obj3);
}
void tst_QItemDelegate::decoration()
{
Q_CHECK_PAINTEVENTS
QFETCH(int, type);
QFETCH(QSize, size);
QFETCH(QSize, expected);
QTableWidget table(1, 1);
TestItemDelegate delegate;
table.setItemDelegate(&delegate);
table.show();
QApplication::setActiveWindow(&table);
QVERIFY(QTest::qWaitForWindowActive(&table));
QVariant value;
switch ((QVariant::Type)type) {
case QVariant::Pixmap: {
QPixmap pm(size);
pm.fill(Qt::black);
value = pm;
break;
}
case QVariant::Image: {
QImage img(size, QImage::Format_Mono);
memset(img.bits(), 0, img.byteCount());
value = img;
break;
}
case QVariant::Icon: {
QPixmap pm(size);
pm.fill(Qt::black);
value = QIcon(pm);
break;
}
case QVariant::Color:
value = QColor(Qt::green);
break;
default:
break;
}
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(Qt::DecorationRole, value);
table.setItem(0, 0, item);
item->setSelected(true);
QApplication::processEvents();
QTRY_COMPARE(delegate.decorationRect.size(), expected);
}
void tst_QScreen::orientationChange()
{
qRegisterMetaType<Qt::ScreenOrientation>("Qt::ScreenOrientation");
QScreen *screen = QGuiApplication::primaryScreen();
screen->setOrientationUpdateMask(Qt::LandscapeOrientation | Qt::PortraitOrientation);
QWindowSystemInterface::handleScreenOrientationChange(screen, Qt::LandscapeOrientation);
QWindowSystemInterface::flushWindowSystemEvents();
QTRY_COMPARE(screen->orientation(), Qt::LandscapeOrientation);
QWindowSystemInterface::handleScreenOrientationChange(screen, Qt::PortraitOrientation);
QWindowSystemInterface::flushWindowSystemEvents();
QTRY_COMPARE(screen->orientation(), Qt::PortraitOrientation);
QSignalSpy spy(screen, SIGNAL(orientationChanged(Qt::ScreenOrientation)));
QWindowSystemInterface::handleScreenOrientationChange(screen, Qt::InvertedLandscapeOrientation);
QWindowSystemInterface::flushWindowSystemEvents();
QWindowSystemInterface::handleScreenOrientationChange(screen, Qt::InvertedPortraitOrientation);
QWindowSystemInterface::flushWindowSystemEvents();
QWindowSystemInterface::handleScreenOrientationChange(screen, Qt::LandscapeOrientation);
QWindowSystemInterface::flushWindowSystemEvents();
QTRY_COMPARE(screen->orientation(), Qt::LandscapeOrientation);
QCOMPARE(spy.count(), 1);
spy.clear();
QWindowSystemInterface::handleScreenOrientationChange(screen, Qt::InvertedLandscapeOrientation);
QWindowSystemInterface::flushWindowSystemEvents();
QTRY_COMPARE(screen->orientation(), Qt::LandscapeOrientation);
QCOMPARE(spy.count(), 0);
screen->setOrientationUpdateMask(screen->orientationUpdateMask() | Qt::InvertedLandscapeOrientation);
QTRY_COMPARE(screen->orientation(), Qt::InvertedLandscapeOrientation);
QCOMPARE(spy.count(), 1);
}
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());
}
}
}
void tst_QWaveDecoder::file()
{
QFETCH(QString, file);
QFETCH(tst_QWaveDecoder::Corruption, corruption);
QFETCH(int, channels);
QFETCH(int, samplesize);
QFETCH(int, samplerate);
QFETCH(QAudioFormat::Endian, byteorder);
QFile stream;
stream.setFileName(file);
stream.open(QIODevice::ReadOnly);
QVERIFY(stream.isOpen());
QWaveDecoder waveDecoder(&stream);
QSignalSpy validFormatSpy(&waveDecoder, SIGNAL(formatKnown()));
QSignalSpy parsingErrorSpy(&waveDecoder, SIGNAL(parsingError()));
if (corruption == NotAWav) {
QSKIP("Not all failures detected correctly yet");
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
} else if (corruption == NoSampleData) {
QTRY_COMPARE(validFormatSpy.count(), 1);
QCOMPARE(parsingErrorSpy.count(), 0);
QVERIFY(waveDecoder.audioFormat().isValid());
QVERIFY(waveDecoder.size() == 0);
QVERIFY(waveDecoder.duration() == 0);
} else if (corruption == FormatDescriptor) {
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
} else if (corruption == FormatString) {
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
QVERIFY(!waveDecoder.audioFormat().isValid());
} else if (corruption == DataDescriptor) {
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
QVERIFY(waveDecoder.size() == 0);
} else if (corruption == None) {
QTRY_COMPARE(validFormatSpy.count(), 1);
QCOMPARE(parsingErrorSpy.count(), 0);
QVERIFY(waveDecoder.audioFormat().isValid());
QVERIFY(waveDecoder.size() > 0);
QVERIFY(waveDecoder.duration() == 250);
QAudioFormat format = waveDecoder.audioFormat();
QVERIFY(format.isValid());
QVERIFY(format.channelCount() == channels);
QVERIFY(format.sampleSize() == samplesize);
QVERIFY(format.sampleRate() == samplerate);
if (format.sampleSize() != 8) {
QVERIFY(format.byteOrder() == byteorder);
}
}
stream.close();
}
void tst_QTimer::livelock()
{
/*
New timers created in timer event handlers should not be sent
until the next iteration of the eventloop. Note: this test
depends on the fact that we send posted events before timer
events (since new posted events are not sent until the next
iteration of the eventloop either).
*/
QFETCH(int, interval);
LiveLockTester tester(interval);
QTest::qWait(180); // we have to use wait here, since we're testing timers with a non-zero timeout
QTRY_COMPARE(tester.timeoutsForFirst, 1);
QCOMPARE(tester.timeoutsForExtra, 0);
QTRY_COMPARE(tester.timeoutsForSecond, 1);
#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
if (QSysInfo::WindowsVersion < QSysInfo::WV_XP)
QEXPECT_FAIL("non-zero timer", "Multimedia timers are not available on Windows 2000", Continue);
#elif defined(Q_OS_WINCE)
QEXPECT_FAIL("non-zero timer", "Windows CE devices often too slow", Continue);
#endif
QVERIFY(tester.postEventAtRightTime);
}
void tst_QXARadio_xa::testStopRadio()
{
QVERIFY(radio->service() != 0);
QVERIFY(radio->error() == QRadioTuner::NoError);
QVERIFY(radio->errorString().isEmpty());
QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
radio->stop();
QTRY_COMPARE(stateSpy.count(), 1); // wait for callbacks to complete in symbian API
QCOMPARE(radio->state(), QRadioTuner::StoppedState);
// delete radio;
}
void FlameGraphViewTest::testContextMenu()
{
int targetWidth = 0;
int targetHeight = 0;
{
QMenu testMenu;
testMenu.addActions(QmlProfilerTool::profilerContextMenuActions());
testMenu.addSeparator();
testMenu.show();
QTest::qWaitForWindowExposed(testMenu.window());
targetWidth = testMenu.width() / 2;
int prevHeight = testMenu.height();
QAction dummy(QString("target"), this);
testMenu.addAction(&dummy);
targetHeight = (testMenu.height() + prevHeight) / 2;
}
QTimer timer;
timer.setInterval(50);
timer.start();
connect(&timer, &QTimer::timeout, this, [&]() {
auto activePopup = qApp->activePopupWidget();
if (!activePopup || !activePopup->windowHandle()->isExposed())
return;
QTest::mouseMove(activePopup, QPoint(targetWidth, targetHeight));
QTest::mouseClick(activePopup, Qt::LeftButton, Qt::NoModifier,
QPoint(targetWidth, targetHeight));
if (!manager.isRestrictedToRange()) {
// click somewhere else to remove the menu and return to outer function
QTest::mouseClick(qApp->activePopupWidget(), Qt::LeftButton, Qt::NoModifier,
QPoint(500, 500));
}
});
QTest::mouseMove(&view, QPoint(250, 250));
QSignalSpy spy(&view, SIGNAL(showFullRange()));
QContextMenuEvent event(QContextMenuEvent::Mouse, QPoint(250, 250));
QVERIFY(qApp->notify(&view, &event));
QCOMPARE(spy.count(), 0);
manager.restrictToRange(1, 10);
QVERIFY(qApp->notify(&view, &event));
if (spy.count() != 1)
QTRY_COMPARE(spy.count(), 1);
}
void tst_QColumnView::parentCurrentIndex()
{
QFETCH(int, firstRow);
QFETCH(int, secondRow);
ColumnView view;
TreeModel model;
view.setModel(&model);
view.show();
QModelIndex first;
QModelIndex second;
QModelIndex third;
first = model.index(0, 0, QModelIndex());
second = model.index(firstRow, 0, first);
third = model.index(0, 0, second);
QVERIFY(first.isValid());
QVERIFY(second.isValid());
QVERIFY(third.isValid());
view.setCurrentIndex(third);
QTest::qWait(ANIMATION_DELAY);
QCOMPARE(view.createdColumns[0]->currentIndex(), first);
QCOMPARE(view.createdColumns[1]->currentIndex(), second);
QCOMPARE(view.createdColumns[2]->currentIndex(), third);
first = model.index(0, 0, QModelIndex());
second = model.index(secondRow, 0, first);
third = model.index(0, 0, second);
QVERIFY(first.isValid());
QVERIFY(second.isValid());
QVERIFY(third.isValid());
view.setCurrentIndex(third);
QTest::qWait(ANIMATION_DELAY);
QTRY_COMPARE(view.createdColumns[0]->currentIndex(), first);
QTRY_COMPARE(view.createdColumns[1]->currentIndex(), second);
QTRY_COMPARE(view.createdColumns[2]->currentIndex(), third);
}
void tst_qquickspritesequence::test_framerateAdvance()
{
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("advance.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickSpriteSequence* sprite = window->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
QVERIFY(sprite);
QTRY_COMPARE(sprite->currentSprite(), QLatin1String("secondState"));
delete window;
}
void tst_QNmeaPositionInfoSource::startUpdates()
{
QFETCH(QList<QDateTime>, dateTimes);
QNmeaPositionInfoSource source(m_mode);
QNmeaPositionInfoSourceProxyFactory factory;
QNmeaPositionInfoSourceProxy *proxy = static_cast<QNmeaPositionInfoSourceProxy*>(factory.createProxy(&source));
QSignalSpy spyUpdate(proxy->source(), SIGNAL(positionUpdated(QGeoPositionInfo)));
proxy->source()->startUpdates();
for (int i=0; i<dateTimes.count(); i++)
proxy->feedUpdate(dateTimes[i]);
QTRY_COMPARE(spyUpdate.count(), dateTimes.count());
}
void tst_QXARadio_xa::testBand()
{
qRegisterMetaType<QRadioTuner::Band>("QRadioTuner::Band");
QVERIFY(radio->isBandSupported(QRadioTuner::FM));
QVERIFY(!radio->isBandSupported(QRadioTuner::SW));
radio->setBand(QRadioTuner::FM);
QVERIFY(radio->band() == QRadioTuner::FM);
if(radio->isBandSupported(QRadioTuner::AM)) {
QSignalSpy readSignal(radio, SIGNAL(bandChanged(QRadioTuner::Band)));
radio->setBand(QRadioTuner::AM);
QTRY_COMPARE(readSignal.count(), 1); // wait for callbacks to complete in symbian API
QVERIFY(radio->band() == QRadioTuner::AM);
}
}
void tst_QCameraBackend::testExposureMode()
{
#if !defined(Q_WS_MAEMO_6)
QSKIP("Capture exposure parameters are supported only on mobile platforms");
#endif
QCamera camera;
QCameraExposure *exposure = camera.exposure();
#ifdef Q_WS_MAEMO_6
QEXPECT_FAIL("", "Camerabin reports Manual exposure instead of Auto", Continue);
#endif
QCOMPARE(exposure->exposureMode(), QCameraExposure::ExposureAuto);
// Night
exposure->setExposureMode(QCameraExposure::ExposureNight);
QCOMPARE(exposure->exposureMode(), QCameraExposure::ExposureNight);
camera.start();
QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(exposure->exposureMode(), QCameraExposure::ExposureNight);
camera.unload();
QTRY_COMPARE(camera.status(), QCamera::UnloadedStatus);
#ifdef Q_WS_MAEMO_6
//resource policy doesn't work correctly when resource is released and immediately requested again.
QTest::qWait(250);
#endif
// Auto
exposure->setExposureMode(QCameraExposure::ExposureAuto);
QCOMPARE(exposure->exposureMode(), QCameraExposure::ExposureAuto);
camera.start();
QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(exposure->exposureMode(), QCameraExposure::ExposureAuto);
}
void testQOfonoNetworkOperator()
{
QSignalSpy scanFinished(m, SIGNAL(scanFinished()));
QSignalSpy networkOperatorsChanged(m, SIGNAL(networkOperatorsChanged(QStringList)));
m->scan();
QTRY_COMPARE(scanFinished.count(), 1);
scanFinished.takeFirst();
QTRY_COMPARE(networkOperatorsChanged.count(), 1);
QStringList opIdList = networkOperatorsChanged.takeFirst().at(0).toStringList();
QVERIFY(opIdList.count() > 0);
int op1 = -1;
int op2 = -1;
QList<QOfonoNetworkOperator *> opList;
foreach(QString opId, opIdList)
{
QOfonoNetworkOperator *op = new QOfonoNetworkOperator(this);
op->setOperatorPath(opId);
opList << op;
if (op1 == -1 && op->status() == "current")
op1 = opIdList.indexOf(opId);
if (op2 == -1 && op->status() == "available")
op2 = opIdList.indexOf(opId);
}
//QTBUG-18362
void tst_qdeclarativebehaviors::delayedRegistration()
{
QDeclarativeEngine engine;
QDeclarativeComponent c(&engine, SRCDIR "/data/delayedRegistration.qml");
QDeclarativeRectangle *rect = qobject_cast<QDeclarativeRectangle*>(c.create());
QVERIFY(rect != 0);
QDeclarativeItem *innerRect = rect->property("myItem").value<QDeclarativeItem*>();
QVERIFY(innerRect != 0);
QCOMPARE(innerRect->property("x").toInt(), int(0));
QTRY_COMPARE(innerRect->property("x").toInt(), int(100));
}
void tst_QKeySequenceEdit::testKeys()
{
QFETCH(Qt::Key, key);
QFETCH(Qt::KeyboardModifiers, modifiers);
QFETCH(QKeySequence, keySequence);
QKeySequenceEdit edit;
QSignalSpy spy(&edit, SIGNAL(editingFinished()));
QTest::keyPress(&edit, key, modifiers);
QTest::keyRelease(&edit, key, modifiers);
QCOMPARE(spy.count(), 0);
QCOMPARE(edit.keySequence(), keySequence);
QTRY_COMPARE(spy.count(), 1);
}
void TestGui::testDatabaseSettings()
{
triggerAction("actionChangeDatabaseSettings");
QWidget* dbSettingsWidget = m_dbWidget->findChild<QWidget*>("databaseSettingsWidget");
QSpinBox* transformRoundsSpinBox = dbSettingsWidget->findChild<QSpinBox*>("transformRoundsSpinBox");
transformRoundsSpinBox->setValue(100);
QTest::keyClick(transformRoundsSpinBox, Qt::Key_Enter);
// wait for modified timer
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("Save*"));
QCOMPARE(m_db->transformRounds(), Q_UINT64_C(100));
triggerAction("actionDatabaseSave");
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("Save"));
checkDatabase();
}
void tst_QNmeaPositionInfoSource::requestUpdate_waitForValidDateTime()
{
QFETCH(QByteArray, bytes);
QFETCH(QList<QDateTime>, dateTimes);
QNmeaPositionInfoSource source(m_mode);
QNmeaPositionInfoSourceProxyFactory factory;
QNmeaPositionInfoSourceProxy *proxy = static_cast<QNmeaPositionInfoSourceProxy*>(factory.createProxy(&source));
QSignalSpy spy(proxy->source(), SIGNAL(positionUpdated(QGeoPositionInfo)));
proxy->source()->requestUpdate();
proxy->feedBytes(bytes);
QTRY_COMPARE(spy.count(), 1);
QCOMPARE(spy[0][0].value<QGeoPositionInfo>().timestamp(), dateTimes[0]);
}
void dynamicPropertyAnimation(const QByteArray & propertyName, T toValue)
{
QQuickView view(testFileUrl("MyItem.qml"));
QQuickItem * item = qobject_cast<QQuickItem *>(view.rootObject());
QVERIFY(item);
QQmlProperty testProp(item, propertyName);
QPropertyAnimation animation(item, propertyName, this);
animation.setEndValue(toValue);
QVERIFY(animation.targetObject() == item);
QVERIFY(animation.propertyName() == propertyName);
QVERIFY(animation.endValue().value<T>() == toValue);
animation.start();
QVERIFY(animation.state() == QAbstractAnimation::Running);
QTest::qWait(animation.duration());
QTRY_COMPARE(testProp.read().value<T>(), toValue);
}
void checkResponse()
{
qDebug()<<"checkResponse begin";
if (check)
{
// response is QMap<quint16, QByteArray>
checkResponseType e = mExpectedResult.value<checkResponseType>();
checkResponseType r = mTarget->requestResponse(mId).value<checkResponseType>();
QCOMPARE(e, r);
}
else
{
QTRY_COMPARE(mTarget->requestResponse(mId), mExpectedResult);
}
qDebug()<<"checkResponse end";
}
void tst_QMenu::overrideMenuAction()
{
//test the override menu action by first creating an action to which we set its menu
QMainWindow w;
QAction *aFileMenu = new QAction("&File", &w);
w.menuBar()->addAction(aFileMenu);
QMenu *m = new QMenu(&w);
QAction *menuaction = m->menuAction();
connect(m, SIGNAL(triggered(QAction*)), SLOT(onActivated(QAction*)));
aFileMenu->setMenu(m); //this sets the override menu action for the QMenu
QCOMPARE(m->menuAction(), aFileMenu);
#ifdef Q_WS_MAC
QSKIP("On Mac, we need to create native key events to test menu action activation", SkipAll);
#elif defined(Q_OS_WINCE)
QSKIP("On Windows CE, we need to create native key events to test menu action activation", SkipAll);
#elif defined(Q_OS_SYMBIAN)
QSKIP("On Symbian OS, we need to create native key events to test menu action activation", SkipAll);
#endif
QAction *aQuit = new QAction("Quit", &w);
aQuit->setShortcut(QKeySequence("Ctrl+X"));
m->addAction(aQuit);
w.show();
QApplication::setActiveWindow(&w);
w.setFocus();
QTest::qWaitForWindowShown(&w);
QTRY_VERIFY(w.hasFocus());
//test of the action inside the menu
QTest::keyClick(&w, Qt::Key_X, Qt::ControlModifier);
QTRY_COMPARE(activated, aQuit);
//test if the menu still pops out
QTest::keyClick(&w, Qt::Key_F, Qt::AltModifier);
QTRY_VERIFY(m->isVisible());
delete aFileMenu;
//after the deletion of the override menu action,
//the menu should have its default menu action back
QCOMPARE(m->menuAction(), menuaction);
}
void TestCntActions::phonenumberCallSupport()
{
QContact contact;
//Add phonenumber to contact
QContactPhoneNumber number;
number.setSubTypes(QContactPhoneNumber::SubTypeMobile);
number.setNumber("555111222");
contact.saveDetail(&number);
m_manager->saveContact(&contact);
//verify that the contact has a phonenumber
QList<QContactPhoneNumber> numberList = contact.details<QContactPhoneNumber>();
QVERIFY(numberList.count() > 0);
//get the actions
QList<QContactActionDescriptor> actionDescriptors = contact.availableActions();
QStringList actions;
for (int i = 0;i < actionDescriptors.count();i++)
{
QString action = actionDescriptors.at(i).actionName();
actions << action;
}
//verify that it includes the actiosn
QVERIFY(actions.contains("call", Qt::CaseInsensitive));
//verify that the action works
QList<QContactActionDescriptor> callActionDescriptors = QContactAction::actionDescriptors("call", "symbian");
QVERIFY(callActionDescriptors.count() == 1);
QContactAction *callAction = QContactAction::action(callActionDescriptors.at(0));
QVERIFY(callAction != 0);
QContactAction::State state = callAction->state();
QVERIFY(state != QContactAction::InactiveState);
QVERIFY(callAction->isDetailSupported(numberList.at(0)) == true);
QList<QContactDetail> supportedDetails = callAction->supportedDetails(contact);
QVERIFY(supportedDetails.count() != 0);
QVariantMap variantMap = callAction->metaData();
QVERIFY(variantMap.count() == 0);
variantMap = callAction->results();
QVERIFY(variantMap.count() == 0);
QSignalSpy spyCallAction(callAction, SIGNAL(stateChanged(QContactAction::State)));
callAction->invokeAction(contact, numberList.at(0));
callAction->invokeAction(contact);
QTRY_COMPARE(spyCallAction.count(), 2); // make sure the signal was emitted exactly one time
delete callAction;
}
void tst_provisioning()
{
QSignalSpy conadd(m, SIGNAL(contextAdded(QString)));
Q_FOREACH (const QString con, m->contexts()) {
m->removeContext(con);
}
QTRY_COMPARE(m->contexts(), QStringList());
m->addContext("internet");
QTRY_COMPARE(conadd.count(), 1);
QString contextid = conadd.takeFirst().at(0).toString();
QVERIFY(m->contexts().contains(contextid));
QOfonoConnectionContext* context = new QOfonoConnectionContext(this);
context->setContextPath(contextid);
QSignalSpy apn(context, SIGNAL(accessPointNameChanged(QString)));
context->setAccessPointName("internet");
QTRY_COMPARE(apn.count(), 1);
QCOMPARE(apn.takeFirst().at(0).toString(), QString("internet"));
QString operatorString = "Optus";
QString mcc = "505";
QString mnc = "02";
QCOMPARE(context->validateProvisioning(operatorString, mcc, mnc),true);
context->setAccessPointName("yesinternet");
QTRY_COMPARE(apn.count(), 1);
QCOMPARE(apn.takeFirst().at(0).toString(), QString("yesinternet"));
QCOMPARE(context->validateProvisioning(operatorString, mcc, mnc),true);
context->setAccessPointName("connect");
QTRY_COMPARE(apn.count(), 1);
QCOMPARE(apn.takeFirst().at(0).toString(), QString("connect"));
QCOMPARE(context->validateProvisioning(operatorString, mcc, mnc),true);
context->setAccessPointName("connectcap");
QTRY_COMPARE(apn.count(), 1);
QCOMPARE(apn.takeFirst().at(0).toString(), QString("connectcap"));
QCOMPARE(context->validateProvisioning(operatorString, mcc, mnc),true);
context->setAccessPointName("test");
QTRY_COMPARE(apn.count(), 1);
QCOMPARE(apn.takeFirst().at(0).toString(), QString("test"));
QCOMPARE(context->validateProvisioning(operatorString, mcc, mnc),false);
}
void tst_QCameraBackend::testCameraCapture()
{
QCamera camera;
QCameraImageCapture imageCapture(&camera);
//prevents camera to flash during the test
camera.exposure()->setFlashMode(QCameraExposure::FlashOff);
QVERIFY(!imageCapture.isReadyForCapture());
QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(int,QImage)));
QSignalSpy savedSignal(&imageCapture, SIGNAL(imageSaved(int,QString)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int, QCameraImageCapture::Error,QString)));
imageCapture.capture();
QTRY_COMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QCameraImageCapture::NotReadyError);
QCOMPARE(capturedSignal.size(), 0);
errorSignal.clear();
camera.start();
QTRY_VERIFY(imageCapture.isReadyForCapture());
QCOMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(errorSignal.size(), 0);
int id = imageCapture.capture();
QTRY_VERIFY(!savedSignal.isEmpty());
QCOMPARE(capturedSignal.size(), 1);
QCOMPARE(capturedSignal.last().first().toInt(), id);
QCOMPARE(errorSignal.size(), 0);
QCOMPARE(imageCapture.error(), QCameraImageCapture::NoError);
QCOMPARE(savedSignal.last().first().toInt(), id);
QString location = savedSignal.last().last().toString();
QVERIFY(!location.isEmpty());
QVERIFY(QFileInfo(location).exists());
QImageReader reader(location);
reader.setScaledSize(QSize(320,240));
QVERIFY(!reader.read().isNull());
QFile(location).remove();
}
void TestGui::testAddEntry()
{
EntryView* entryView = m_dbWidget->findChild<EntryView*>("entryView");
QAction* entryNewAction = m_mainWindow->findChild<QAction*>("actionEntryNew");
QVERIFY(entryNewAction->isEnabled());
QToolBar* toolBar = m_mainWindow->findChild<QToolBar*>("toolBar");
QWidget* entryNewWidget = toolBar->widgetForAction(entryNewAction);
QVERIFY(entryNewWidget->isVisible());
QVERIFY(entryNewWidget->isEnabled());
QTest::mouseClick(entryNewWidget, Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::EditMode);
EditEntryWidget* editEntryWidget = m_dbWidget->findChild<EditEntryWidget*>("editEntryWidget");
QLineEdit* titleEdit = editEntryWidget->findChild<QLineEdit*>("titleEdit");
QTest::keyClicks(titleEdit, "test");
QDialogButtonBox* editEntryWidgetButtonBox = editEntryWidget->findChild<QDialogButtonBox*>("buttonBox");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::ViewMode);
QModelIndex item = entryView->model()->index(1, 1);
Entry* entry = entryView->entryFromIndex(item);
QCOMPARE(entry->title(), QString("test"));
QCOMPARE(entry->historyItems().size(), 0);
// wait for modified timer
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("NewDatabase.kdbx*"));
QAction* entryEditAction = m_mainWindow->findChild<QAction*>("actionEntryEdit");
QVERIFY(entryEditAction->isEnabled());
QWidget* entryEditWidget = toolBar->widgetForAction(entryEditAction);
QVERIFY(entryEditWidget->isVisible());
QVERIFY(entryEditWidget->isEnabled());
QTest::mouseClick(entryEditWidget, Qt::LeftButton);
QCOMPARE(m_dbWidget->currentMode(), DatabaseWidget::EditMode);
QTest::keyClicks(titleEdit, "something");
QTest::mouseClick(editEntryWidgetButtonBox->button(QDialogButtonBox::Ok), Qt::LeftButton);
QCOMPARE(entry->title(), QString("testsomething"));
QCOMPARE(entry->historyItems().size(), 1);
}
void TestCntActions::urlSupport()
{
QContact contact;
QContactUrl url;
url.setUrl("www.test.com");
contact.saveDetail(&url);
m_manager->saveContact(&contact);
//one number exist in contact
QList<QContactUrl> urlList = contact.details<QContactUrl>();
QVERIFY(urlList.count() == 1);
//no actions expected
QList<QContactActionDescriptor> actionDescriptors = contact.availableActions();
QStringList actions;
for (int i = 0;i < actionDescriptors.count();i++)
{
QString action = actionDescriptors.at(i).actionName();
actions << action;
}
QVERIFY(actions.count() == 1);
QVERIFY(actions.contains("url", Qt::CaseInsensitive));
//pick first number for the actions
QContactUrl urlAddress = contact.detail<QContactUrl>();
//Test Email action
QList<QContactActionDescriptor> urlActionDescriptors = QContactAction::actionDescriptors("url", "symbian");
QVERIFY(urlActionDescriptors.count() == 1);
QContactAction *urlAction = QContactAction::action(urlActionDescriptors.at(0));
QVERIFY(urlAction != 0);
QVERIFY(urlAction->isDetailSupported(urlList.at(0)) == true);
QList<QContactDetail> supportedDetails = urlAction->supportedDetails(contact);
QVERIFY(supportedDetails.count() != 0);
QVariantMap variantMap = urlAction->metaData();
QVERIFY(variantMap.count() == 0);
variantMap = urlAction->results();
QVERIFY(variantMap.count() == 0);
QSignalSpy spyUrlAction(urlAction, SIGNAL(stateChanged(QContactAction::State)));
urlAction->invokeAction(contact, urlAddress);
urlAction->invokeAction(contact);
QTRY_COMPARE(spyUrlAction.count(), 2); // make sure the signal was emitted exactly once each time
delete urlAction;
}
