void tst_treeviewfind::columns() { // set up tree // search for FOO in // * HEADER1 | HEADER1 // * FOO1 | A // * HEADER2 | FOOHEADER2 // * FOO2 | FOO3 // * HEADER3 | HEADER2 // * A | FOO4 QTreeWidget *tree = new QTreeWidget; tree->setColumnCount(2); QList<QTreeWidgetItem *> toplevelitems; QTreeWidgetItem *item; item = new QTreeWidgetItem((QTreeWidget *)0, QStringList() << QLatin1String("HEADER1") << QLatin1String("HEADER1")); item->addChild(new QTreeWidgetItem((QTreeWidget *)0, QStringList() << QLatin1String("FOO1") << QLatin1String("A"))); toplevelitems << item; item = new QTreeWidgetItem((QTreeWidget *)0, QStringList() << QLatin1String("HEADER2") << QLatin1String("FOOHEADER2")); item->addChild(new QTreeWidgetItem((QTreeWidget *)0, QStringList() << QLatin1String("FOO2") << QLatin1String("FOO3"))); toplevelitems << item; item = new QTreeWidgetItem((QTreeWidget *)0, QStringList() << QLatin1String("HEADER3") << QLatin1String("HEADER3")); item->addChild(new QTreeWidgetItem((QTreeWidget *)0, QStringList() << QLatin1String("A") << QLatin1String("FOO4"))); toplevelitems << item; tree->addTopLevelItems(toplevelitems); // set up Core::ItemViewFind *findSupport = new Core::ItemViewFind(tree); tree->setCurrentItem(toplevelitems.at(0)); QCOMPARE(tree->currentItem()->text(0), QString::fromLatin1("HEADER1")); // find in first column findSupport->findStep(QLatin1String("FOO"), 0); QCOMPARE(tree->currentItem(), toplevelitems.at(0)->child(0)); // find in second column of node with children findSupport->findStep(QLatin1String("FOO"), 0); QCOMPARE(tree->currentItem(), toplevelitems.at(1)); // again find in first column findSupport->findStep(QLatin1String("FOO"), 0); QCOMPARE(tree->currentItem(), toplevelitems.at(1)->child(0)); // don't stay in item if multiple columns match, and find in second column findSupport->findStep(QLatin1String("FOO"), 0); QCOMPARE(tree->currentItem(), toplevelitems.at(2)->child(0)); // wrap findSupport->findStep(QLatin1String("FOO"), 0); QCOMPARE(tree->currentItem(), toplevelitems.at(0)->child(0)); // backwards tree->setCurrentItem(toplevelitems.at(2)->child(0)); QCOMPARE(tree->currentItem()->text(0), QString::fromLatin1("A")); findSupport->findStep(QLatin1String("FOO"), Core::FindBackward); QCOMPARE(tree->currentItem(), toplevelitems.at(1)->child(0)); findSupport->findStep(QLatin1String("FOO"), Core::FindBackward); QCOMPARE(tree->currentItem(), toplevelitems.at(1)); findSupport->findStep(QLatin1String("FOO"), Core::FindBackward); QCOMPARE(tree->currentItem(), toplevelitems.at(0)->child(0)); findSupport->findStep(QLatin1String("FOO"), Core::FindBackward); QCOMPARE(tree->currentItem(), toplevelitems.at(2)->child(0)); // clean up delete findSupport; delete tree; }
void tst_QAtomicIntegerXX::fetchAndXor() { QFETCH(LargeInt, value); QAtomicInteger<T> atomic(value); T zero = 0; T pattern = T(Q_UINT64_C(0xcccccccccccccccc)); T minusOne = T(~0); QCOMPARE(atomic.fetchAndXorRelaxed(zero), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorRelaxed(pattern), T(value)); QCOMPARE(atomic.load(), T(value ^ pattern)); QCOMPARE(atomic.fetchAndXorRelaxed(pattern), T(value ^ pattern)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorRelaxed(minusOne), T(value)); QCOMPARE(atomic.load(), T(~value)); QCOMPARE(atomic.fetchAndXorRelaxed(minusOne), T(~value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorAcquire(zero), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorAcquire(pattern), T(value)); QCOMPARE(atomic.load(), T(value ^ pattern)); QCOMPARE(atomic.fetchAndXorAcquire(pattern), T(value ^ pattern)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorAcquire(minusOne), T(value)); QCOMPARE(atomic.load(), T(~value)); QCOMPARE(atomic.fetchAndXorAcquire(minusOne), T(~value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorRelease(zero), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorRelease(pattern), T(value)); QCOMPARE(atomic.load(), T(value ^ pattern)); QCOMPARE(atomic.fetchAndXorRelease(pattern), T(value ^ pattern)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorRelease(minusOne), T(value)); QCOMPARE(atomic.load(), T(~value)); QCOMPARE(atomic.fetchAndXorRelease(minusOne), T(~value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorOrdered(zero), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorOrdered(pattern), T(value)); QCOMPARE(atomic.load(), T(value ^ pattern)); QCOMPARE(atomic.fetchAndXorOrdered(pattern), T(value ^ pattern)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndXorOrdered(minusOne), T(value)); QCOMPARE(atomic.load(), T(~value)); QCOMPARE(atomic.fetchAndXorOrdered(minusOne), T(~value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic ^= zero, T(value)); QCOMPARE(atomic ^= pattern, T(value ^ pattern)); QCOMPARE(atomic ^= pattern, T(value)); QCOMPARE(atomic ^= minusOne, T(~value)); QCOMPARE(atomic ^= minusOne, T(value)); }
void FilterApiTest::testDeclinationFilter() { // Input data to feed to the filter CompassData inputData[] = { CompassData(0, 0, 0), CompassData(0, 1, 0), CompassData(0, 0, 2), CompassData(0, 0, 0), CompassData(0, 340, 5), CompassData(0, 359, 0), CompassData(0, 0, 8), CompassData(0, 1, 1) }; FilterBase* declinationFilter = DeclinationFilter::factoryMethod(); QVERIFY(declinationFilter); system("gconftool-2 --set /system/osso/location/settings/magneticvariation --type int 50"); int key = dynamic_cast<DeclinationFilter*>(declinationFilter)->declinationCorrection(); QCOMPARE(key, 50); // Expected output data CompassData expectedResult[] = { CompassData(0, 0, 0, 0 + key, 0), CompassData(0, 1, 0, 1 + key, 1), CompassData(0, 0, 2, 0 + key, 0), CompassData(0, 0, 0, 0 + key, 0), CompassData(0, 340, 5, 30, 340), CompassData(0, 359, 0, 49, 359), CompassData(0, 0, 8, 0 + key, 0), CompassData(0, 1, 1, 1 + key, 1) }; QVERIFY2((sizeof(inputData)) == (sizeof(expectedResult)), "Test function error: Input and output count does not match."); int numInputs = (sizeof(inputData) / sizeof(TimedXyzData)); Bin filterBin; DummyAdaptor<CompassData> dummyAdaptor; RingBuffer<CompassData> outputBuffer(10); filterBin.add(&dummyAdaptor, "adapter"); filterBin.add(declinationFilter, "declinationfilter"); filterBin.add(&outputBuffer, "buffer"); filterBin.join("adapter", "source", "declinationfilter", "sink"); filterBin.join("declinationfilter", "source", "buffer", "sink"); DummyDataEmitter<CompassData> dbusEmitter; Bin marshallingBin; marshallingBin.add(&dbusEmitter, "testdataemitter"); outputBuffer.join(&dbusEmitter); /* Setup data */ dummyAdaptor.setTestData(numInputs, inputData); dbusEmitter.setExpectedData(numInputs, expectedResult); marshallingBin.start(); filterBin.start(); // Start sends data once, so start from index 1. for (int i = 0; i < numInputs; ++i) { dummyAdaptor.pushNewData(); } filterBin.stop(); marshallingBin.stop(); QCOMPARE (dummyAdaptor.getDataCount(), dbusEmitter.numSamplesReceived()); delete declinationFilter; system("gconftool-2 --set /system/osso/location/settings/magneticvariation --type int 0"); }
void tst_QAtomicIntegerXX::fetchAndStore() { QFETCH(LargeInt, value); T newValue = ~T(value); QAtomicInteger<T> atomic(value); QCOMPARE(atomic.fetchAndStoreRelaxed(newValue), T(value)); QCOMPARE(atomic.load(), newValue); QCOMPARE(atomic.fetchAndStoreRelaxed(value), newValue); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndStoreAcquire(newValue), T(value)); QCOMPARE(atomic.load(), newValue); QCOMPARE(atomic.fetchAndStoreAcquire(value), newValue); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndStoreRelease(newValue), T(value)); QCOMPARE(atomic.loadAcquire(), newValue); QCOMPARE(atomic.fetchAndStoreRelease(value), newValue); QCOMPARE(atomic.loadAcquire(), T(value)); QCOMPARE(atomic.fetchAndStoreOrdered(newValue), T(value)); QCOMPARE(atomic.loadAcquire(), newValue); QCOMPARE(atomic.fetchAndStoreOrdered(value), newValue); QCOMPARE(atomic.loadAcquire(), T(value)); }
void tst_QAtomicIntegerXX::fetchAndOr() { QFETCH(LargeInt, value); QAtomicInteger<T> atomic(value); T zero = 0; T one = 1; T minusOne = T(~0); QCOMPARE(atomic.fetchAndOrRelaxed(zero), T(value)); QCOMPARE(atomic.fetchAndOrRelaxed(one), T(value)); QCOMPARE(atomic.load(), T(value | 1)); QCOMPARE(atomic.fetchAndOrRelaxed(minusOne), T(value | 1)); QCOMPARE(atomic.load(), minusOne); atomic.store(value); QCOMPARE(atomic.fetchAndOrAcquire(zero), T(value)); QCOMPARE(atomic.fetchAndOrAcquire(one), T(value)); QCOMPARE(atomic.load(), T(value | 1)); QCOMPARE(atomic.fetchAndOrAcquire(minusOne), T(value | 1)); QCOMPARE(atomic.load(), minusOne); atomic.store(value); QCOMPARE(atomic.fetchAndOrRelease(zero), T(value)); QCOMPARE(atomic.fetchAndOrRelease(one), T(value)); QCOMPARE(atomic.load(), T(value | 1)); QCOMPARE(atomic.fetchAndOrRelease(minusOne), T(value | 1)); QCOMPARE(atomic.load(), minusOne); atomic.store(value); QCOMPARE(atomic.fetchAndOrOrdered(zero), T(value)); QCOMPARE(atomic.fetchAndOrOrdered(one), T(value)); QCOMPARE(atomic.load(), T(value | 1)); QCOMPARE(atomic.fetchAndOrOrdered(minusOne), T(value | 1)); QCOMPARE(atomic.load(), minusOne); atomic.store(value); QCOMPARE(atomic |= zero, T(value)); QCOMPARE(atomic |= one, T(value | 1)); QCOMPARE(atomic |= minusOne, minusOne); }
void tst_QToolBar::toolButtonStyle() { { QToolBar tb; QSignalSpy spy(&tb, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle))); // no-op QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); tb.setToolButtonStyle(Qt::ToolButtonIconOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(spy.count(), 0); tb.setToolButtonStyle(Qt::ToolButtonTextOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextOnly); QCOMPARE(spy.count(), 1); spy.clear(); // no-op tb.setToolButtonStyle(Qt::ToolButtonTextOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextOnly); QCOMPARE(spy.count(), 0); tb.setToolButtonStyle(Qt::ToolButtonIconOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(spy.count(), 1); spy.clear(); // no-op tb.setToolButtonStyle(Qt::ToolButtonIconOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(spy.count(), 0); tb.setToolButtonStyle(Qt::ToolButtonTextBesideIcon); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextBesideIcon); QCOMPARE(spy.count(), 1); spy.clear(); // no-op tb.setToolButtonStyle(Qt::ToolButtonTextBesideIcon); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextBesideIcon); QCOMPARE(spy.count(), 0); tb.setToolButtonStyle(Qt::ToolButtonTextUnderIcon); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextUnderIcon); QCOMPARE(spy.count(), 1); spy.clear(); // no-op tb.setToolButtonStyle(Qt::ToolButtonTextUnderIcon); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonTextUnderIcon); QCOMPARE(spy.count(), 0); tb.setToolButtonStyle(Qt::ToolButtonFollowStyle); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonFollowStyle); QCOMPARE(spy.count(), 1); } { QMainWindow mw; QToolBar tb; QSignalSpy mwSpy(&mw, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle))); QSignalSpy tbSpy(&tb, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle))); mw.setToolButtonStyle(Qt::ToolButtonTextBesideIcon); // explicitly set the tb to the default tb.setToolButtonStyle(Qt::ToolButtonIconOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(tbSpy.count(), 0); mw.addToolBar(&tb); // tb icon size should not change since it has been explicitly set QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(tbSpy.count(), 0); mw.setToolButtonStyle(Qt::ToolButtonIconOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(tbSpy.count(), 0); mw.setToolButtonStyle(Qt::ToolButtonTextOnly); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(tbSpy.count(), 0); mw.setToolButtonStyle(Qt::ToolButtonTextUnderIcon); QCOMPARE(tb.toolButtonStyle(), Qt::ToolButtonIconOnly); QCOMPARE(tbSpy.count(), 0); // note: there is no way to clear the explicitly set tool // button style... once you explicitly set it, the toolbar // will never follow the mainwindow again } }
void tst_QAtomicIntegerXX::refDeref() { QFETCH(LargeInt, value); const bool needToPreventOverflow = TypeIsSigned && value == std::numeric_limits<T>::max(); const bool needToPreventUnderflow = TypeIsSigned && value == std::numeric_limits<T>::min(); T nextValue = T(value); if (!needToPreventOverflow) ++nextValue; T prevValue = T(value); if (!needToPreventUnderflow) --prevValue; QAtomicInteger<T> atomic(value); if (!needToPreventOverflow) { QCOMPARE(atomic.ref(), (nextValue != 0)); QCOMPARE(atomic.load(), nextValue); QCOMPARE(atomic.deref(), (value != 0)); } QCOMPARE(atomic.load(), T(value)); if (!needToPreventUnderflow) { QCOMPARE(atomic.deref(), (prevValue != 0)); QCOMPARE(atomic.load(), prevValue); QCOMPARE(atomic.ref(), (value != 0)); } QCOMPARE(atomic.load(), T(value)); if (!needToPreventOverflow) { QCOMPARE(++atomic, nextValue); QCOMPARE(--atomic, T(value)); } if (!needToPreventUnderflow) { QCOMPARE(--atomic, prevValue); QCOMPARE(++atomic, T(value)); } if (!needToPreventOverflow) { QCOMPARE(atomic++, T(value)); QCOMPARE(atomic--, nextValue); } if (!needToPreventUnderflow) { QCOMPARE(atomic--, T(value)); QCOMPARE(atomic++, prevValue); } QCOMPARE(atomic.load(), T(value)); }
void TestKeePass1Reader::testBasic() { QVERIFY(m_db->deletedObjects().isEmpty()); QCOMPARE(m_db->rootGroup()->children().size(), 2); Group* group1 = m_db->rootGroup()->children().at(0); QVERIFY(!group1->uuid().isNull()); QCOMPARE(group1->name(), QString("Internet")); QCOMPARE(group1->children().size(), 2); QCOMPARE(group1->entries().size(), 2); QCOMPARE(group1->iconNumber(), 1); Entry* entry11 = group1->entries().at(0); QVERIFY(!entry11->uuid().isNull()); QCOMPARE(entry11->title(), QString("Test entry")); QCOMPARE(entry11->iconNumber(), 1); QCOMPARE(entry11->username(), QString("I")); QCOMPARE(entry11->url(), QString("http://example.com/")); QCOMPARE(entry11->password(), QString("secretpassword")); QCOMPARE(entry11->notes(), QString("Lorem ipsum\ndolor sit amet")); QVERIFY(entry11->timeInfo().expires()); QCOMPARE(entry11->timeInfo().expiryTime(), genDT(2012, 5, 9, 10, 32)); QCOMPARE(entry11->attachments()->keys().size(), 1); QCOMPARE(entry11->attachments()->keys().first(), QString("attachment.txt")); QCOMPARE(entry11->attachments()->value("attachment.txt"), QByteArray("hello world\n")); Entry* entry12 = group1->entries().at(1); QCOMPARE(entry12->title(), QString("")); QCOMPARE(entry12->iconNumber(), 0); QCOMPARE(entry12->username(), QString("")); QCOMPARE(entry12->url(), QString("")); QCOMPARE(entry12->password(), QString("")); QCOMPARE(entry12->notes(), QString("")); QVERIFY(!entry12->timeInfo().expires()); QCOMPARE(entry12->attachments()->keys().size(), 0); Group* group11 = group1->children().at(0); QCOMPARE(group11->name(), QString("Subgroup 1")); QCOMPARE(group11->children().size(), 1); Group* group111 = group11->children().at(0); QCOMPARE(group111->name(), QString("Unexpanded")); QCOMPARE(group111->children().size(), 1); Group* group1111 = group111->children().at(0); QCOMPARE(group1111->name(), QString("abc")); QCOMPARE(group1111->children().size(), 0); Group* group12 = group1->children().at(1); QCOMPARE(group12->name(), QString("Subgroup 2")); QCOMPARE(group12->children().size(), 0); Group* group2 = m_db->rootGroup()->children().at(1); QCOMPARE(group2->name(), QString("eMail")); QCOMPARE(group2->entries().size(), 1); QCOMPARE(group2->iconNumber(), 19); reopenDatabase(m_db, "masterpw", QString()); }
void KisLayerTest::testCreation() { const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->colorSpace("RGBA", 0); KisImageSP image = new KisImage(0, 512, 512, colorSpace, "layer test"); KisLayerSP layer = new TestLayer(image, "test", OPACITY_OPAQUE); QCOMPARE(layer->name(), QString("test")); QCOMPARE(layer->opacity(), OPACITY_OPAQUE); QCOMPARE(layer->image(), image); QCOMPARE(layer->colorSpace(), image->colorSpace()); QCOMPARE(layer->visible(), true); QCOMPARE(layer->userLocked(), false); QCOMPARE(layer->temporary(), false); image->addNode(layer, image->rootLayer()); QBitArray channels(4); channels.fill(true); layer->setChannelFlags(channels); QVERIFY(layer->channelFlags().count() == 4); QCOMPARE(layer->channelFlags().at(0), true); QCOMPARE(layer->channelFlags().at(1), true); QCOMPARE(layer->channelFlags().at(2), true); QCOMPARE(layer->channelFlags().at(3), true); layer->setOpacity(OPACITY_TRANSPARENT); QCOMPARE(layer->opacity(), OPACITY_TRANSPARENT); layer->setPercentOpacity(100); QCOMPARE(layer->opacity(), OPACITY_OPAQUE); layer->setPercentOpacity(0); QCOMPARE(layer->opacity(), OPACITY_TRANSPARENT); }
void TestKeePass1Reader::testMasterKey() { QVERIFY(m_db->hasKey()); QCOMPARE(m_db->transformRounds(), static_cast<quint64>(713)); }
void TestKeePass1Reader::testAutoType() { Group* group = m_db->rootGroup()->children().at(0)->children().at(0); QCOMPARE(group->entries().size(), 2); Entry* entry1 = group->entries().at(0); QCOMPARE(entry1->notes(), QString("last line")); QCOMPARE(entry1->defaultAutoTypeSequence(), QString("{USERNAME}{ENTER}")); QCOMPARE(entry1->autoTypeAssociations()->size(), 5); QCOMPARE(entry1->autoTypeAssociations()->get(0).sequence, QString("")); QCOMPARE(entry1->autoTypeAssociations()->get(0).window, QString("a window")); QCOMPARE(entry1->autoTypeAssociations()->get(1).sequence, QString("")); QCOMPARE(entry1->autoTypeAssociations()->get(1).window, QString("a second window")); QCOMPARE(entry1->autoTypeAssociations()->get(2).sequence, QString("{PASSWORD}{ENTER}")); QCOMPARE(entry1->autoTypeAssociations()->get(2).window, QString("Window Nr 1a")); QCOMPARE(entry1->autoTypeAssociations()->get(3).sequence, QString("{PASSWORD}{ENTER}")); QCOMPARE(entry1->autoTypeAssociations()->get(3).window, QString("Window Nr 1b")); QCOMPARE(entry1->autoTypeAssociations()->get(4).sequence, QString("")); QCOMPARE(entry1->autoTypeAssociations()->get(4).window, QString("Window 2")); Entry* entry2 = group->entries().at(1); QCOMPARE(entry2->notes(), QString("start line\nend line")); QCOMPARE(entry2->defaultAutoTypeSequence(), QString("")); QCOMPARE(entry2->autoTypeAssociations()->size(), 2); QCOMPARE(entry2->autoTypeAssociations()->get(0).sequence, QString("")); QCOMPARE(entry2->autoTypeAssociations()->get(0).window, QString("Main Window")); QCOMPARE(entry2->autoTypeAssociations()->get(1).sequence, QString("")); QCOMPARE(entry2->autoTypeAssociations()->get(1).window, QString("Test Window")); }
void TestStelSphericalGeometry::testOctahedronPolygon() { QVERIFY(OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(0.8,0.1,0))); QVERIFY(OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(1,0.1,0))); QVERIFY(OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(0.5,0.,0))); // Check points outside triangle QVERIFY(!OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(0.,0.1,0))); QVERIFY(!OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(-1.,-1.,0))); // Check that the corners are included into the triangle QVERIFY(OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(0,0,0))); QVERIFY(OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(1,0,0))); QVERIFY(OctahedronPolygon::triangleContains2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0), Vec3d(1,1,0))); QVERIFY(OctahedronPolygon::isTriangleConvexPositive2D(Vec3d(0,0,0), Vec3d(1,0,0), Vec3d(1,1,0))); SubContour contour(smallSquareConvex.getConvexContour()); OctahedronPolygon splittedSub(contour); QCOMPARE(splittedSub.getArea(), smallSquareConvex.getArea()); //QVector<Vec3d> va = northPoleSquare.getOutlineVertexArray().vertex; //QCOMPARE(va.size(),16); //va = southPoleSquare.getOutlineVertexArray().vertex; //QCOMPARE(va.size(),16); // Copy OctahedronPolygon splittedSubCopy; splittedSubCopy = splittedSub; QCOMPARE(splittedSub.getArea(), splittedSubCopy.getArea()); double oldArea = splittedSubCopy.getArea(); splittedSub = OctahedronPolygon(); QCOMPARE(splittedSub.getArea(), 0.); QCOMPARE(splittedSubCopy.getArea(), oldArea); splittedSubCopy.inPlaceIntersection(splittedSub); QCOMPARE(splittedSubCopy.getArea(), 0.); QCOMPARE(southPoleSquare.getArea(), northPoleSquare.getArea()); QCOMPARE(southPoleSquare.getIntersection(northPoleSquare)->getArea(), 0.); QCOMPARE(southPoleSquare.getUnion(northPoleSquare)->getArea(), 2.*southPoleSquare.getArea()); QCOMPARE(southPoleSquare.getSubtraction(northPoleSquare)->getArea(), southPoleSquare.getArea()); QCOMPARE(northPoleSquare.getIntersection(northPoleSquare)->getArea(), northPoleSquare.getArea()); QCOMPARE(northPoleSquare.getUnion(northPoleSquare)->getArea(), northPoleSquare.getArea()); QCOMPARE(northPoleSquare.getSubtraction(northPoleSquare)->getArea(), 0.); // Test binary IO QByteArray ar; QBuffer buf(&ar); buf.open(QIODevice::WriteOnly); QDataStream out(&buf); out << northPoleSquare.getOctahedronPolygon(); buf.close(); QVERIFY(!ar.isEmpty()); // Re-read it OctahedronPolygon northPoleSquareRead; buf.open(QIODevice::ReadOnly); QDataStream in(&buf); in >> northPoleSquareRead; buf.close(); QVERIFY(!northPoleSquareRead.isEmpty()); QCOMPARE(northPoleSquareRead.getArea(), northPoleSquare.getArea()); QVERIFY(northPoleSquareRead.intersects(northPoleSquare.getOctahedronPolygon())); // Spherical cap with aperture > 90 deg SphericalCap cap1(Vec3d(0,0,1), std::cos(95.*M_PI/180.)); qDebug() << "---------------------"; OctahedronPolygon northCapPoly = cap1.getOctahedronPolygon(); qDebug() << "---------------------"; qDebug() << northCapPoly.getArea() << OctahedronPolygon::getAllSkyOctahedronPolygon().getArea()/2; QVERIFY(northCapPoly.getArea()>OctahedronPolygon::getAllSkyOctahedronPolygon().getArea()/2); }
void TestQgsProjectStorage::testMemoryStorage() { QString dataDir( TEST_DATA_DIR ); // defined in CmakeLists.txt QString layerPath = dataDir + "/points.shp"; QgsVectorLayer *layer1 = new QgsVectorLayer( layerPath, QStringLiteral( "points" ), QStringLiteral( "ogr" ) ); QVERIFY( layer1->isValid() ); MemoryStorage *memStorage = new MemoryStorage; QgsApplication::projectStorageRegistry()->registerProjectStorage( memStorage ); QVERIFY( QgsApplication::projectStorageRegistry()->projectStorages().contains( memStorage ) ); QCOMPARE( memStorage->listProjects( QString() ).count(), 0 ); QgsProject prj1; prj1.setTitle( "best project ever" ); prj1.addMapLayer( layer1 ); prj1.setFileName( "memory:project1" ); // let's use the aux storage as well - so that the project will include aux database as well int fldCnt0 = layer1->fields().count(); QgsAuxiliaryLayer *layerAux = prj1.auxiliaryStorage()->createAuxiliaryLayer( layer1->fields().at( 0 ), layer1 ); layer1->setAuxiliaryLayer( layerAux ); layerAux->addAttribute( QgsField( "fld_aux", QVariant::Int ) ); layerAux->commitChanges(); QCOMPARE( fldCnt0, 6 ); QCOMPARE( layer1->fields().count(), 7 ); bool writeOk = prj1.write(); QVERIFY( writeOk ); QCOMPARE( memStorage->listProjects( QString() ).count(), 1 ); QVERIFY( prj1.absoluteFilePath().isEmpty() ); QCOMPARE( prj1.baseName(), QString( "project1" ) ); QVERIFY( prj1.lastModified().secsTo( QDateTime::currentDateTime() ) < 1 ); // read the project back QgsProject prj2; prj2.setFileName( "memory:project1" ); bool readOk = prj2.read(); QVERIFY( readOk ); QCOMPARE( prj2.mapLayers().count(), 1 ); QCOMPARE( prj2.title(), QString( "best project ever" ) ); // let's check that our stuff from auxiliary database got stored written and read QgsVectorLayer *prj2layer1 = qobject_cast<QgsVectorLayer *>( prj2.mapLayers().constBegin().value() ); QVERIFY( prj2layer1 ); QCOMPARE( prj2layer1->fields().count(), 7 ); QCOMPARE( prj2layer1->fields().at( 6 ).name(), QString( "auxiliary_storage_fld_aux" ) ); // test project-related variables for project storage QgsExpressionContext expressionContext; expressionContext.appendScope( QgsExpressionContextUtils::projectScope( &prj2 ) ); QCOMPARE( QgsExpression( "@project_path" ).evaluate( &expressionContext ).toString(), QString( "memory:project1" ) ); QCOMPARE( QgsExpression( "@project_basename" ).evaluate( &expressionContext ).toString(), QString( "project1" ) ); // test access of non-existent project QgsProject prj3; prj3.setFileName( "memory:nooooooooo!" ); bool readInvalidOk = prj3.read(); QVERIFY( !readInvalidOk ); // test metadata access QgsProjectStorage::Metadata meta1; bool readMetaOk = memStorage->readProjectStorageMetadata( "memory:project1", meta1 ); QVERIFY( readMetaOk ); QCOMPARE( meta1.name, QString( "project1" ) ); QVERIFY( meta1.lastModified.secsTo( QDateTime::currentDateTime() ) < 1 ); QgsProjectStorage::Metadata metaX; bool readMetaInvalidOk = memStorage->readProjectStorageMetadata( "memory:projectXYZ", metaX ); QVERIFY( !readMetaInvalidOk ); // test removal bool removeInvalidOk = memStorage->removeProject( "memory:projectXYZ" ); QVERIFY( !removeInvalidOk ); QCOMPARE( memStorage->listProjects( QString() ).count(), 1 ); bool removeOk = memStorage->removeProject( "memory:project1" ); QVERIFY( removeOk ); QCOMPARE( memStorage->listProjects( QString() ).count(), 0 ); QgsApplication::projectStorageRegistry()->unregisterProjectStorage( memStorage ); }
void tst_QFileInfo::canonicalFilePath() { const QString fileName("tmp.canon"); QFile tempFile(fileName); QVERIFY(tempFile.open(QFile::WriteOnly)); QFileInfo fi(tempFile.fileName()); QCOMPARE(fi.canonicalFilePath(), QDir::currentPath() + "/" + fileName); tempFile.remove(); // This used to crash on Mac, verify that it doesn't anymore. QFileInfo info("/tmp/../../../../../../../../../../../../../../../../../"); info.canonicalFilePath(); #if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN) // This used to crash on Mac QFileInfo dontCrash(QLatin1String("/")); QCOMPARE(dontCrash.canonicalFilePath(), QLatin1String("/")); #endif #ifndef Q_OS_WIN // test symlinks QFile::remove("link.lnk"); { QFile file(SRCDIR "tst_qfileinfo.cpp"); if (file.link("link.lnk")) { QFileInfo info1(file); QFileInfo info2("link.lnk"); QCOMPARE(info1.canonicalFilePath(), info2.canonicalFilePath()); } } # if !defined(Q_OS_SYMBIAN) // Symbian doesn't support links to directories { const QString link(QDir::tempPath() + QDir::separator() + "tst_qfileinfo"); QFile::remove(link); QFile file(QDir::currentPath()); if (file.link(link)) { QFile tempfile("tempfile.txt"); tempfile.open(QIODevice::ReadWrite); tempfile.write("This file is generated by the QFileInfo autotest."); QVERIFY(tempfile.flush()); tempfile.close(); QFileInfo info1("tempfile.txt"); QFileInfo info2(link + QDir::separator() + "tempfile.txt"); QVERIFY(info1.exists()); QVERIFY(info2.exists()); QCOMPARE(info1.canonicalFilePath(), info2.canonicalFilePath()); QFileInfo info3(link + QDir::separator() + "link.lnk"); QFileInfo info4(SRCDIR "tst_qfileinfo.cpp"); QVERIFY(!info3.canonicalFilePath().isEmpty()); QCOMPARE(info4.canonicalFilePath(), info3.canonicalFilePath()); tempfile.remove(); } } { QString link(QDir::tempPath() + QDir::separator() + "tst_qfileinfo" + QDir::separator() + "link_to_tst_qfileinfo"); QFile::remove(link); QFile file(QDir::tempPath() + QDir::separator() + "tst_qfileinfo" + QDir::separator() + "tst_qfileinfo.cpp"); if (file.link(link)) { QFileInfo info1("tst_qfileinfo.cpp"); QFileInfo info2(link); QCOMPARE(info1.canonicalFilePath(), info2.canonicalFilePath()); } } # endif #endif }
void tst_QToolBar::actionGeometry() { QToolBar tb; QAction action1(0); QAction action2(0); QAction action3(0); QAction action4(0); tb.addAction(&action1); tb.addAction(&action2); tb.addAction(&action3); tb.addAction(&action4); tb.show(); QVERIFY(QTest::qWaitForWindowExposed(&tb)); QList<QToolBarExtension *> extensions = tb.findChildren<QToolBarExtension *>(); QRect rect01; QRect rect02; QRect rect03; QRect rect04; QMenu *popupMenu = 0; if (extensions.size() != 0) { QToolBarExtension *extension = extensions.at(0); if (extension->isVisible()) { QRect rect0 = extension->geometry(); QTest::mouseClick( extension, Qt::LeftButton, 0, rect0.center(), -1 ); QApplication::processEvents(); popupMenu = qobject_cast<QMenu *>(extension->menu()); rect01 = popupMenu->actionGeometry(&action1); rect02 = popupMenu->actionGeometry(&action2); rect03 = popupMenu->actionGeometry(&action3); rect04 = popupMenu->actionGeometry(&action4); } } QRect rect1 = tb.actionGeometry(&action1); QRect rect2 = tb.actionGeometry(&action2); QRect rect3 = tb.actionGeometry(&action3); QRect rect4 = tb.actionGeometry(&action4); QVERIFY(rect1.isValid()); QVERIFY(!rect1.isNull()); QVERIFY(!rect1.isEmpty()); QVERIFY(rect2.isValid()); QVERIFY(!rect2.isNull()); QVERIFY(!rect2.isEmpty()); QVERIFY(rect3.isValid()); QVERIFY(!rect3.isNull()); QVERIFY(!rect3.isEmpty()); QVERIFY(rect4.isValid()); QVERIFY(!rect4.isNull()); QVERIFY(!rect4.isEmpty()); if (rect01.isValid()) QCOMPARE(popupMenu->actionAt(rect01.center()), &action1); else QCOMPARE(tb.actionAt(rect1.center()), &action1); if (rect02.isValid()) QCOMPARE(popupMenu->actionAt(rect02.center()), &action2); else QCOMPARE(tb.actionAt(rect2.center()), &action2); if (rect03.isValid()) QCOMPARE(popupMenu->actionAt(rect03.center()), &action3); else QCOMPARE(tb.actionAt(rect3.center()), &action3); if (rect04.isValid()) QCOMPARE(popupMenu->actionAt(rect04.center()), &action4); else QCOMPARE(tb.actionAt(rect4.center()), &action4); }
void KisLayerTest::testOrdering() { const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->colorSpace("RGBA", 0); KisImageSP image = new KisImage(0, 512, 512, colorSpace, "layer test"); KisLayerSP layer1 = new TestLayer(image, "layer1", OPACITY_OPAQUE); KisLayerSP layer2 = new TestLayer(image, "layer2", OPACITY_OPAQUE); KisLayerSP layer3 = new TestLayer(image, "layer3", OPACITY_OPAQUE); QVERIFY(layer1->name() == "layer1"); QVERIFY(layer2->name() == "layer2"); QVERIFY(layer3->name() == "layer3"); /* +---------+ | layer 2 | | layer 3 | | layer 1 | |root | +---------+ */ QVERIFY(image->addNode(layer1, image->rootLayer())); QVERIFY(image->addNode(layer2, image->rootLayer())); QVERIFY(image->addNode(layer3, image->rootLayer(), layer1)); QCOMPARE((int) image->nlayers(), 4); QVERIFY(layer1->parent() == image->root()); QVERIFY(layer2->parent() == image->root()); QVERIFY(layer3->parent() == image->root()); QVERIFY(image->rootLayer()->firstChild() == layer1.data()); QVERIFY(image->rootLayer()->lastChild() == layer2.data()); QVERIFY(image->rootLayer()->at(0) == layer1.data()); QVERIFY(image->rootLayer()->at(1) == layer3.data()); QVERIFY(image->rootLayer()->at(2) == layer2.data()); QVERIFY(image->rootLayer()->index(layer1) == 0); QVERIFY(image->rootLayer()->index(layer3) == 1); QVERIFY(image->rootLayer()->index(layer2) == 2); QVERIFY(layer3->prevSibling() == layer1.data()); QVERIFY(layer2->prevSibling() == layer3.data()); QVERIFY(layer1->prevSibling() == 0); QVERIFY(layer3->nextSibling() == layer2.data()); QVERIFY(layer2->nextSibling() == 0); QVERIFY(layer1->nextSibling() == layer3.data()); /* +---------+ | layer 3 | | layer 2 | | layer 1 | |root | +---------+ */ QVERIFY(image->moveNode(layer2, image->rootLayer(), layer1)); QVERIFY(image->rootLayer()->at(0) == layer1.data()); QVERIFY(image->rootLayer()->at(1) == layer2.data()); QVERIFY(image->rootLayer()->at(2) == layer3.data()); QVERIFY(image->rootLayer()->firstChild() == layer1.data()); QVERIFY(image->rootLayer()->lastChild() == layer3.data()); QVERIFY(image->rootLayer()->index(layer1) == 0); QVERIFY(image->rootLayer()->index(layer2) == 1); QVERIFY(image->rootLayer()->index(layer3) == 2); QVERIFY(layer3->prevSibling() == layer2.data()); QVERIFY(layer2->prevSibling() == layer1.data()); QVERIFY(layer1->prevSibling() == 0); QVERIFY(layer3->nextSibling() == 0); QVERIFY(layer2->nextSibling() == layer3.data()); QVERIFY(layer1->nextSibling() == layer2.data()); }
void tst_QToolBar::iconSize() { { QToolBar tb; QSignalSpy spy(&tb, SIGNAL(iconSizeChanged(QSize))); // the default is determined by the style const int metric = tb.style()->pixelMetric(QStyle::PM_ToolBarIconSize); const QSize defaultIconSize = QSize(metric, metric); const QSize smallIconSize = QSize(metric / 2, metric / 2); const QSize largeIconSize = QSize(metric * 2, metric * 2); QCOMPARE(tb.iconSize(), defaultIconSize); tb.setIconSize(defaultIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(spy.count(), 0); spy.clear(); tb.setIconSize(largeIconSize); QCOMPARE(tb.iconSize(), largeIconSize); QCOMPARE(spy.count(), 1); QCOMPARE(spy.first().first().toSize(), largeIconSize); // no-op spy.clear(); tb.setIconSize(largeIconSize); QCOMPARE(tb.iconSize(), largeIconSize); QCOMPARE(spy.count(), 0); spy.clear(); tb.setIconSize(defaultIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(spy.count(), 1); QCOMPARE(spy.first().first().toSize(), defaultIconSize); // no-op spy.clear(); tb.setIconSize(defaultIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(spy.count(), 0); spy.clear(); tb.setIconSize(smallIconSize); QCOMPARE(tb.iconSize(), smallIconSize); QCOMPARE(spy.count(), 1); QCOMPARE(spy.first().first().toSize(), smallIconSize); // no-op spy.clear(); tb.setIconSize(smallIconSize); QCOMPARE(tb.iconSize(), smallIconSize); QCOMPARE(spy.count(), 0); // setting the icon size to an invalid QSize will reset the // iconSize property to the default tb.setIconSize(QSize()); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(spy.size(), 1); QCOMPARE(spy.first().first().toSize(), defaultIconSize); spy.clear(); } { QMainWindow mw; QToolBar tb; QSignalSpy mwSpy(&mw, SIGNAL(iconSizeChanged(QSize))); QSignalSpy tbSpy(&tb, SIGNAL(iconSizeChanged(QSize))); // the default is determined by the style const int metric = tb.style()->pixelMetric(QStyle::PM_ToolBarIconSize); const QSize defaultIconSize = QSize(metric, metric); const QSize smallIconSize = QSize(metric / 2, metric / 2); const QSize largeIconSize = QSize(metric * 2, metric * 2); mw.setIconSize(smallIconSize); // explicitly set it to the default tb.setIconSize(defaultIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(tbSpy.count(), 0); mw.addToolBar(&tb); // tb icon size should not change since it has been explicitly set QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(tbSpy.count(), 0); mw.setIconSize(largeIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(tbSpy.count(), 0); mw.setIconSize(defaultIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(tbSpy.count(), 0); mw.setIconSize(smallIconSize); QCOMPARE(tb.iconSize(), defaultIconSize); QCOMPARE(tbSpy.count(), 0); // resetting to the default should cause the toolbar to take // on the mainwindow's icon size tb.setIconSize(QSize()); QCOMPARE(tb.iconSize(), smallIconSize); QCOMPARE(tbSpy.size(), 1); QCOMPARE(tbSpy.first().first().toSize(), smallIconSize); tbSpy.clear(); } }
void CalendarTester::workIntervals() { Calendar t("Test"); QDate wdate(2006,1,2); DateTime before = DateTime(wdate.addDays(-1), QTime()); DateTime after = DateTime(wdate.addDays(1), QTime()); QTime t1(8,0,0); QTime t2(10,0,0); DateTime wdt1( wdate, t1 ); DateTime wdt2( wdate, t2 ); int length = t1.msecsTo( t2 ); CalendarDay *day = new CalendarDay(wdate, CalendarDay::Working); day->addInterval( TimeInterval( t1, length ) ); t.addDay(day); QVERIFY(t.findDay(wdate) == day); AppointmentIntervalList lst = t.workIntervals( before, after, 100. ); QCOMPARE( lst.map().count(), 1 ); QCOMPARE( wdate, lst.map().values().first().startTime().date() ); QCOMPARE( t1, lst.map().values().first().startTime().time() ); QCOMPARE( wdate, lst.map().values().first().endTime().date() ); QCOMPARE( t2, lst.map().values().first().endTime().time() ); QCOMPARE( 100., lst.map().values().first().load() ); QTime t3( 12, 0, 0 ); day->addInterval( TimeInterval( t3, length ) ); lst = t.workIntervals( before, after, 100. ); Debug::print( lst ); QCOMPARE( lst.map().count(), 2 ); QCOMPARE( wdate, lst.map().values().first().startTime().date() ); QCOMPARE( t1, lst.map().values().first().startTime().time() ); QCOMPARE( wdate, lst.map().values().first().endTime().date() ); QCOMPARE( t2, lst.map().values().first().endTime().time() ); QCOMPARE( 100., lst.map().values().first().load() ); QCOMPARE( wdate, lst.map().values().at( 1 ).startTime().date() ); QCOMPARE( t3, lst.map().values().at( 1 ).startTime().time() ); QCOMPARE( wdate, lst.map().values().at( 1 ).endTime().date() ); QCOMPARE( t3.addMSecs( length ), lst.map().values().at( 1 ).endTime().time() ); QCOMPARE( 100., lst.map().values().at( 1 ).load() ); }
void tst_QToolBar::actionTriggered() { QToolBar tb; connect(&tb, SIGNAL(actionTriggered(QAction*)), SLOT(slot(QAction*))); QAction action1(0); QAction action2(0); QAction action3(0); QAction action4(0); tb.addAction(&action1); tb.addAction(&action2); tb.addAction(&action3); tb.addAction(&action4); tb.show(); QVERIFY(QTest::qWaitForWindowExposed(&tb)); QList<QToolBarExtension *> extensions = tb.findChildren<QToolBarExtension *>(); QRect rect01; QRect rect02; QRect rect03; QRect rect04; QMenu *popupMenu = 0; if (extensions.size() != 0) { QToolBarExtension *extension = extensions.at(0); if (extension->isVisible()) { QRect rect0 = extension->geometry(); QTest::mouseClick( extension, Qt::LeftButton, 0, rect0.center(), -1 ); QApplication::processEvents(); popupMenu = qobject_cast<QMenu *>(extension->menu()); rect01 = popupMenu->actionGeometry(&action1); rect02 = popupMenu->actionGeometry(&action2); rect03 = popupMenu->actionGeometry(&action3); rect04 = popupMenu->actionGeometry(&action4); } } QRect rect1 = tb.actionGeometry(&action1); QRect rect2 = tb.actionGeometry(&action2); QRect rect3 = tb.actionGeometry(&action3); QRect rect4 = tb.actionGeometry(&action4); QAbstractButton *button1 = 0; QAbstractButton *button2 = 0; QAbstractButton *button3 = 0; QAbstractButton *button4 = 0; if (!rect01.isValid()) { button1 = qobject_cast<QAbstractButton *>(tb.childAt(rect1.center())); QVERIFY(button1 != 0); } if (!rect02.isValid()) { button2 = qobject_cast<QAbstractButton *>(tb.childAt(rect2.center())); QVERIFY(button2 != 0); } if (!rect03.isValid()) { button3 = qobject_cast<QAbstractButton *>(tb.childAt(rect3.center())); QVERIFY(button3 != 0); } if (!rect04.isValid()) { button4 = qobject_cast<QAbstractButton *>(tb.childAt(rect4.center())); QVERIFY(button4 != 0); } ::triggered = 0; if (!rect01.isValid()) QTest::mouseClick(button1, Qt::LeftButton); else QTest::mouseClick(popupMenu, Qt::LeftButton, 0, rect01.center(), -1 ); QCOMPARE(::triggered, &action1); ::triggered = 0; if (!rect02.isValid()) QTest::mouseClick(button2, Qt::LeftButton); else QTest::mouseClick(popupMenu, Qt::LeftButton, 0, rect02.center(), -1 ); QCOMPARE(::triggered, &action2); ::triggered = 0; if (!rect03.isValid()) QTest::mouseClick(button3, Qt::LeftButton); else QTest::mouseClick(popupMenu, Qt::LeftButton, 0, rect03.center(), -1 ); QCOMPARE(::triggered, &action3); ::triggered = 0; if (!rect04.isValid()) QTest::mouseClick(button4, Qt::LeftButton); else QTest::mouseClick(popupMenu, Qt::LeftButton, 0, rect04.center(), -1 ); QCOMPARE(::triggered, &action4); }
void tst_QToolBar::allowedAreas() { QToolBar tb; QSignalSpy spy(&tb, SIGNAL(allowedAreasChanged(Qt::ToolBarAreas))); // default QCOMPARE((int)tb.allowedAreas(), (int)Qt::AllToolBarAreas); QVERIFY(tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::BottomToolBarArea)); // a single dock window area tb.setAllowedAreas(Qt::LeftToolBarArea); QCOMPARE((int)tb.allowedAreas(), (int)Qt::LeftToolBarArea); QVERIFY(tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); tb.setAllowedAreas(Qt::RightToolBarArea); QCOMPARE((int)tb.allowedAreas(), (int)Qt::RightToolBarArea); QVERIFY(!tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); tb.setAllowedAreas(Qt::TopToolBarArea); QCOMPARE((int)tb.allowedAreas(), (int)Qt::TopToolBarArea); QVERIFY(!tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); tb.setAllowedAreas(Qt::BottomToolBarArea); QCOMPARE((int)tb.allowedAreas(), (int)Qt::BottomToolBarArea); QVERIFY(!tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); // multiple dock window areas tb.setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea); QCOMPARE(tb.allowedAreas(), Qt::TopToolBarArea | Qt::BottomToolBarArea); QVERIFY(!tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); tb.setAllowedAreas(Qt::LeftToolBarArea | Qt::RightToolBarArea); QCOMPARE(tb.allowedAreas(), Qt::LeftToolBarArea | Qt::RightToolBarArea); QVERIFY(tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); tb.setAllowedAreas(Qt::TopToolBarArea | Qt::LeftToolBarArea); QCOMPARE(tb.allowedAreas(), Qt::TopToolBarArea | Qt::LeftToolBarArea); QVERIFY(tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); tb.setAllowedAreas(Qt::BottomToolBarArea | Qt::RightToolBarArea); QCOMPARE(tb.allowedAreas(), Qt::BottomToolBarArea | Qt::RightToolBarArea); QVERIFY(!tb.isAreaAllowed(Qt::LeftToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::RightToolBarArea)); QVERIFY(!tb.isAreaAllowed(Qt::TopToolBarArea)); QVERIFY(tb.isAreaAllowed(Qt::BottomToolBarArea)); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::ToolBarAreas *>(spy.at(0).value(0).constData()), tb.allowedAreas()); spy.clear(); tb.setAllowedAreas(tb.allowedAreas()); QCOMPARE(spy.count(), 0); }
void tst_QAtomicIntegerXX::testAndSet3() { QFETCH(LargeInt, value); T newValue = ~T(value); T oldValue; QAtomicInteger<T> atomic(value); QVERIFY(atomic.testAndSetRelaxed(value, newValue, oldValue)); QCOMPARE(atomic.load(), newValue); QVERIFY(!atomic.testAndSetRelaxed(value, newValue, oldValue)); QCOMPARE(oldValue, newValue); QVERIFY(atomic.testAndSetRelaxed(newValue, value, oldValue)); QCOMPARE(atomic.load(), T(value)); QVERIFY(atomic.testAndSetAcquire(value, newValue, oldValue)); QCOMPARE(atomic.load(), newValue); QVERIFY(!atomic.testAndSetAcquire(value, newValue, oldValue)); QCOMPARE(oldValue, newValue); QVERIFY(atomic.testAndSetAcquire(newValue, value, oldValue)); QCOMPARE(atomic.load(), T(value)); QVERIFY(atomic.testAndSetRelease(value, newValue, oldValue)); QCOMPARE(atomic.loadAcquire(), newValue); QVERIFY(!atomic.testAndSetRelease(value, newValue, oldValue)); QCOMPARE(oldValue, newValue); QVERIFY(atomic.testAndSetRelease(newValue, value, oldValue)); QCOMPARE(atomic.loadAcquire(), T(value)); QVERIFY(atomic.testAndSetOrdered(value, newValue, oldValue)); QCOMPARE(atomic.loadAcquire(), newValue); QVERIFY(!atomic.testAndSetOrdered(value, newValue, oldValue)); QCOMPARE(oldValue, newValue); QVERIFY(atomic.testAndSetOrdered(newValue, value, oldValue)); QCOMPARE(atomic.loadAcquire(), T(value)); }
void tst_QToolBar::orientation() { QToolBar tb; QCOMPARE(tb.orientation(), Qt::Horizontal); QSignalSpy spy(&tb, SIGNAL(orientationChanged(Qt::Orientation))); tb.setOrientation(Qt::Vertical); QCOMPARE(tb.orientation(), Qt::Vertical); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::Orientation *>(spy.at(0).value(0).constData()), tb.orientation()); spy.clear(); tb.setOrientation(tb.orientation()); QCOMPARE(spy.count(), 0); tb.setOrientation(Qt::Horizontal); QCOMPARE(tb.orientation(), Qt::Horizontal); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::Orientation *>(spy.at(0).value(0).constData()), tb.orientation()); spy.clear(); tb.setOrientation(tb.orientation()); QCOMPARE(spy.count(), 0); tb.setOrientation(Qt::Vertical); QCOMPARE(tb.orientation(), Qt::Vertical); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::Orientation *>(spy.at(0).value(0).constData()), tb.orientation()); spy.clear(); tb.setOrientation(tb.orientation()); QCOMPARE(spy.count(), 0); tb.setOrientation(Qt::Horizontal); QCOMPARE(tb.orientation(), Qt::Horizontal); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::Orientation *>(spy.at(0).value(0).constData()), tb.orientation()); spy.clear(); tb.setOrientation(tb.orientation()); QCOMPARE(spy.count(), 0); tb.setOrientation(Qt::Vertical); QCOMPARE(tb.orientation(), Qt::Vertical); QCOMPARE(spy.count(), 1); QCOMPARE(*static_cast<const Qt::Orientation *>(spy.at(0).value(0).constData()), tb.orientation()); spy.clear(); tb.setOrientation(tb.orientation()); QCOMPARE(spy.count(), 0); }
void tst_QAtomicIntegerXX::fetchAndSub() { QFETCH(LargeInt, value); QAtomicInteger<T> atomic(value); T parcel1 = 42; T parcel2 = T(0-parcel1); const bool needToPreventOverflow = TypeIsSigned && value > std::numeric_limits<T>::max() - parcel1; const bool needToPreventUnderflow = TypeIsSigned && value < std::numeric_limits<T>::min() - parcel2; T newValue1 = T(value); if (!needToPreventUnderflow) newValue1 -= parcel1; T newValue2 = T(value); if (!needToPreventOverflow) newValue2 -= parcel2; if (!needToPreventUnderflow) { QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), T(value)); QCOMPARE(atomic.load(), newValue1); QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), newValue1); } QCOMPARE(atomic.load(), T(value)); if (!needToPreventOverflow) { QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), T(value)); QCOMPARE(atomic.load(), newValue2); QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), newValue2); } QCOMPARE(atomic.load(), T(value)); if (!needToPreventUnderflow) { QCOMPARE(atomic.fetchAndSubAcquire(parcel1), T(value)); QCOMPARE(atomic.load(), newValue1); QCOMPARE(atomic.fetchAndSubAcquire(parcel2), newValue1); } QCOMPARE(atomic.load(), T(value)); if (!needToPreventOverflow) { QCOMPARE(atomic.fetchAndSubAcquire(parcel2), T(value)); QCOMPARE(atomic.load(), newValue2); QCOMPARE(atomic.fetchAndSubAcquire(parcel1), newValue2); } QCOMPARE(atomic.load(), T(value)); if (!needToPreventUnderflow) { QCOMPARE(atomic.fetchAndSubRelease(parcel1), T(value)); QCOMPARE(atomic.loadAcquire(), newValue1); QCOMPARE(atomic.fetchAndSubRelease(parcel2), newValue1); } QCOMPARE(atomic.loadAcquire(), T(value)); if (!needToPreventOverflow) { QCOMPARE(atomic.fetchAndSubRelease(parcel2), T(value)); QCOMPARE(atomic.loadAcquire(), newValue2); QCOMPARE(atomic.fetchAndSubRelease(parcel1), newValue2); } QCOMPARE(atomic.loadAcquire(), T(value)); if (!needToPreventUnderflow) { QCOMPARE(atomic.fetchAndSubOrdered(parcel1), T(value)); QCOMPARE(atomic.loadAcquire(), newValue1); QCOMPARE(atomic.fetchAndSubOrdered(parcel2), newValue1); } QCOMPARE(atomic.loadAcquire(), T(value)); if (!needToPreventOverflow) { QCOMPARE(atomic.fetchAndSubOrdered(parcel2), T(value)); QCOMPARE(atomic.loadAcquire(), newValue2); QCOMPARE(atomic.fetchAndSubOrdered(parcel1), newValue2); } QCOMPARE(atomic.loadAcquire(), T(value)); // operator-= if (!needToPreventUnderflow) { QCOMPARE(atomic -= parcel1, newValue1); QCOMPARE(atomic -= parcel2, T(value)); } if (!needToPreventOverflow) { QCOMPARE(atomic -= parcel2, newValue2); QCOMPARE(atomic -= parcel1, T(value)); } }
void tst_QToolBar::addAction() { QToolBar tb; { QAction action(0); QCOMPARE(tb.actions().count(), 0); tb.addAction(&action); QCOMPARE(tb.actions().count(), 1); QCOMPARE(tb.actions()[0], &action); tb.clear(); QCOMPARE(tb.actions().count(), 0); } { QString text = "text"; QPixmap pm(32, 32); pm.fill(Qt::blue); QIcon icon = pm; QAction *action1 = tb.addAction(text); QCOMPARE(text, action1->text()); QAction *action2 = tb.addAction(icon, text); QCOMPARE(icon, action2->icon()); QCOMPARE(text, action2->text()); QAction *action3 = tb.addAction(text, this, SLOT(slot())); QCOMPARE(text, action3->text()); QAction *action4 = tb.addAction(icon, text, this, SLOT(slot())); QCOMPARE(icon, action4->icon()); QCOMPARE(text, action4->text()); QCOMPARE(tb.actions().count(), 4); QCOMPARE(tb.actions()[0], action1); QCOMPARE(tb.actions()[1], action2); QCOMPARE(tb.actions()[2], action3); QCOMPARE(tb.actions()[3], action4); tb.clear(); QCOMPARE(tb.actions().count(), 0); } }
void tst_QAtomicIntegerXX::fetchAndAnd() { QFETCH(LargeInt, value); QAtomicInteger<T> atomic(value); T zero = 0; T f = 0xf; T minusOne = T(~0); QCOMPARE(atomic.fetchAndAndRelaxed(minusOne), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndAndRelaxed(f), T(value)); QCOMPARE(atomic.load(), T(value & 0xf)); QCOMPARE(atomic.fetchAndAndRelaxed(zero), T(value & 0xf)); QCOMPARE(atomic.load(), zero); atomic.store(value); QCOMPARE(atomic.fetchAndAndAcquire(minusOne), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndAndAcquire(f), T(value)); QCOMPARE(atomic.load(), T(value & 0xf)); QCOMPARE(atomic.fetchAndAndAcquire(zero), T(value & 0xf)); QCOMPARE(atomic.load(), zero); atomic.store(value); QCOMPARE(atomic.fetchAndAndRelease(minusOne), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndAndRelease(f), T(value)); QCOMPARE(atomic.load(), T(value & 0xf)); QCOMPARE(atomic.fetchAndAndRelease(zero), T(value & 0xf)); QCOMPARE(atomic.load(), zero); atomic.store(value); QCOMPARE(atomic.fetchAndAndOrdered(minusOne), T(value)); QCOMPARE(atomic.load(), T(value)); QCOMPARE(atomic.fetchAndAndOrdered(f), T(value)); QCOMPARE(atomic.load(), T(value & 0xf)); QCOMPARE(atomic.fetchAndAndOrdered(zero), T(value & 0xf)); QCOMPARE(atomic.load(), zero); atomic.store(value); QCOMPARE(atomic &= minusOne, T(value)); QCOMPARE(atomic &= f, T(value & 0xf)); QCOMPARE(atomic &= zero, zero); }
void tst_QToolBar::addWidget() { QToolBar tb; QWidget w(&tb); QAction action1(0); QAction action2(0); tb.addAction(&action1); QAction *widget = tb.addWidget(&w); tb.addAction(&action2); QCOMPARE(tb.actions().count(), 3); QCOMPARE(tb.actions()[0], &action1); QCOMPARE(tb.actions()[1], widget); QCOMPARE(tb.actions()[2], &action2); // it should be possible to reuse the action returned by // addWidget() to place the widget somewhere else in the toolbar tb.removeAction(widget); QCOMPARE(tb.actions().count(), 2); QCOMPARE(tb.actions()[0], &action1); QCOMPARE(tb.actions()[1], &action2); tb.addAction(widget); QCOMPARE(tb.actions().count(), 3); QCOMPARE(tb.actions()[0], &action1); QCOMPARE(tb.actions()[1], &action2); QCOMPARE(tb.actions()[2], widget); tb.clear(); QCOMPARE(tb.actions().count(), 0); }
void FilterApiTest::testOrientationInterpretationFilter() { // Input data to feed to the filter TimedXyzData inputData[] = { TimedXyzData( 0,-981, 0, 0), TimedXyzData(1000000, 981, 0, 0), TimedXyzData(2000000, 0,-981, 0), TimedXyzData(3000000, 0, 981, 0), TimedXyzData(4000000, 0, 0, -981), TimedXyzData(5000000, 0, 0, 981) }; // Expected output data PoseData expectedResult[] = { PoseData( 0, PoseData::RightUp), PoseData(1000000, PoseData::LeftUp), PoseData(2000000, PoseData::BottomDown), PoseData(3000000, PoseData::BottomUp), PoseData(4000000, PoseData::FaceUp), PoseData(5000000, PoseData::FaceDown) }; QVERIFY2((sizeof(inputData) / sizeof(TimedXyzData)) == (sizeof(expectedResult) / sizeof(PoseData)), "Test function error: Input and output count does not match."); int numInputs = (sizeof(inputData) / sizeof(TimedXyzData)); // Build data pipeline Bin filterBin; DummyAdaptor<TimedXyzData> dummyAdaptor; FilterBase* orientationInterpreterFilter = OrientationInterpreter::factoryMethod(); RingBuffer<PoseData> outputBuffer(10); filterBin.add(&dummyAdaptor, "adapter"); filterBin.add(orientationInterpreterFilter, "orientationfilter"); filterBin.add(&outputBuffer, "buffer"); filterBin.join("adapter", "source", "orientationfilter", "accsink"); filterBin.join("orientationfilter", "orientation", "buffer", "sink"); DummyDataEmitter<PoseData> dbusEmitter; Bin marshallingBin; marshallingBin.add(&dbusEmitter, "testdataemitter"); outputBuffer.join(&dbusEmitter); // Setup data dummyAdaptor.setTestData(numInputs, inputData); dbusEmitter.setExpectedData(numInputs, expectedResult); marshallingBin.start(); filterBin.start(); // Start sends data once, so start from index 1. for (int i = 0; i < numInputs; ++i) { dummyAdaptor.pushNewData(); } filterBin.stop(); marshallingBin.stop(); QCOMPARE (dummyAdaptor.getDataCount(), dbusEmitter.numSamplesReceived()); delete orientationInterpreterFilter; }
void tst_QToolBar::insertWidget() { QToolBar tb; QWidget w(&tb); QAction action1(0); QAction action2(0); tb.addAction(&action1); tb.addAction(&action2); QAction *widget = tb.insertWidget(&action2, &w); QCOMPARE(tb.actions().count(), 3); QCOMPARE(tb.actions()[0], &action1); QCOMPARE(tb.actions()[1], widget); QCOMPARE(tb.actions()[2], &action2); // it should be possible to reuse the action returned by // addWidget() to place the widget somewhere else in the toolbar tb.removeAction(widget); QCOMPARE(tb.actions().count(), 2); QCOMPARE(tb.actions()[0], &action1); QCOMPARE(tb.actions()[1], &action2); tb.insertAction(&action1, widget); QCOMPARE(tb.actions().count(), 3); QCOMPARE(tb.actions()[0], widget); QCOMPARE(tb.actions()[1], &action1); QCOMPARE(tb.actions()[2], &action2); tb.clear(); QCOMPARE(tb.actions().count(), 0); { QToolBar tb; QPointer<QWidget> widget = new QWidget; QAction *action = tb.addWidget(widget); QCOMPARE(action->parent(), &tb); QToolBar tb2; tb.removeAction(action); tb2.addAction(action); QVERIFY(widget && widget->parent() == &tb2); QCOMPARE(action->parent(), &tb2); } }
void FilterApiTest::testRotationFilter() { TimedXyzData inputData[] = { TimedXyzData(0, 0, 0, 0), TimedXyzData(1, 0, 0,-500), TimedXyzData(2, 0, 0, 500), TimedXyzData(3, 0,-500, 0), TimedXyzData(4, 0, 500, 0), TimedXyzData(5,-500, 0, 0), TimedXyzData(6, 500, 0, 0), TimedXyzData(7,-500, 0,-500), //~ TimedXyzData(8, 500, 0,-500), TimedXyzData(9, 0,-500,-500), //~ TimedXyzData(10, 0, 500,-500), TimedXyzData(11, 0,-500, 500), //~ TimedXyzData(12, 0, 500, 500), }; TimedXyzData expectedResult[] = { TimedXyzData(0, 0, 0, 0), TimedXyzData(1, 0, 0, 0), TimedXyzData(2, 0, 180, 0), TimedXyzData(3, 90, 0, 0), TimedXyzData(4, -90, 0, 0), TimedXyzData(5, 0, -90, 0), TimedXyzData(6, 0, 90, 0), TimedXyzData(7, 0, -45, 0), //~ TimedXyzData(8, 0, 45, 0), TimedXyzData(9, 45, 0, 0), //~ TimedXyzData(10, -45, 0, 0), TimedXyzData(11, 45, 180, 0), //~ TimedXyzData(12, -45, 180, 0), }; QVERIFY2((sizeof(inputData)) == (sizeof(expectedResult)), "Test function error: Input and output count does not match."); int numInputs = (sizeof(inputData) / sizeof(TimedXyzData)); DummyAdaptor<TimedXyzData> dummyAdaptor; DummyDataEmitter<TimedXyzData> dbusEmitter; FilterBase* rotationFilter = RotationFilter::factoryMethod(); RingBuffer<TimedXyzData> outputBuffer(10); Bin filterBin; filterBin.add(&dummyAdaptor, "adapter"); filterBin.add(rotationFilter, "rotationfilter"); filterBin.add(&outputBuffer, "buffer"); filterBin.join("adapter", "source", "rotationfilter", "accelerometersink"); filterBin.join("rotationfilter", "source", "buffer", "sink"); Bin marshallingBin; marshallingBin.add(&dbusEmitter, "testdataemitter"); outputBuffer.join(&dbusEmitter); /* Setup data */ dummyAdaptor.setTestData(numInputs, inputData); dbusEmitter.setExpectedData(numInputs, expectedResult); marshallingBin.start(); filterBin.start(); // Start sends data once, so start from index 1. for (int i = 0; i < numInputs; ++i) { dummyAdaptor.pushNewData(); } filterBin.stop(); marshallingBin.stop(); QCOMPARE (dummyAdaptor.getDataCount(), dbusEmitter.numSamplesReceived()); delete rotationFilter; }
void ShortcutWing_Test::name() { QCOMPARE(m_wing->name(), QString("Shortcut ") + tr("at") + QString(" ") + QHostAddress(QHostAddress::LocalHost).toString()); }