Rewritten QVERIFY to QCOMPARE so that error message is more informative.

--- engine/test/efx/efx_test.cpp
+++ engine/test/efx/efx_test.cpp
@@ -52,7 +52,7 @@
     QDir dir(INTERNAL_FIXTUREDIR);
     dir.setFilter(QDir::Files);
     dir.setNameFilters(QStringList() << QString("*%1").arg(KExtFixture));
-    QVERIFY(m_doc->fixtureDefCache()->load(dir) == true);
+    QVERIFY(m_doc->fixtureDefCache()->load(dir));
 }

 void EFX_Test::cleanupTestCase()
@@ -72,29 +72,29 @@
 void EFX_Test::initial()
 {
     EFX e(m_doc);
-    QVERIFY(e.type() == Function::EFX);
-    QVERIFY(e.name() == "New EFX");
-    QVERIFY(e.id() == Function::invalidId());
-
-    QVERIFY(e.algorithm() == EFX::Circle);
-    QVERIFY(e.width() == 127);
-    QVERIFY(e.height() == 127);
-    QVERIFY(e.rotation() == 0);
-    QVERIFY(e.xOffset() == 127);
-    QVERIFY(e.yOffset() == 127);
-
-    QVERIFY(e.xFrequency() == 2);
-    QVERIFY(e.yFrequency() == 3);
-    QVERIFY(e.isFrequencyEnabled() == false);
-
-    QVERIFY(e.yPhase() == 0);
-    QVERIFY(e.xPhase() == 90);
-    QVERIFY(e.isPhaseEnabled() == false);
-
-    QVERIFY(e.fixtures().size() == 0);
-    QVERIFY(e.propagationMode() == EFX::Parallel);
-
-    QVERIFY(e.m_fader == NULL);
+    QCOMPARE(e.type(), Function::EFX);
+    QCOMPARE(e.name(), QString("New EFX"));
+    QCOMPARE(e.id(), Function::invalidId());
+
+    QCOMPARE(e.algorithm(), EFX::Circle);
+    QCOMPARE(e.width(), 127);
+    QCOMPARE(e.height(), 127);
+    QCOMPARE(e.rotation(), 0);
+    QCOMPARE(e.xOffset(), 127);
+    QCOMPARE(e.yOffset(), 127);
+
+    QCOMPARE(e.xFrequency(), 2);
+    QCOMPARE(e.yFrequency(), 3);
+    QVERIFY(!e.isFrequencyEnabled());
+
+    QCOMPARE(e.yPhase(), 0);
+    QCOMPARE(e.xPhase(), 90);
+    QVERIFY(!e.isPhaseEnabled());
+
+    QCOMPARE(e.fixtures().size(), 0);
+    QCOMPARE(e.propagationMode(), EFX::Parallel);
+
+    QCOMPARE(e.m_fader, (GenericFader*)(NULL));
     QCOMPARE(e.m_legacyFadeBus, Bus::invalid());
     QCOMPARE(e.m_legacyHoldBus, Bus::invalid());
 }
@@ -102,33 +102,33 @@
 void EFX_Test::algorithmNames()
 {
     QStringList list = EFX::algorithmList();
-    QVERIFY(list.size() == 5);
-    QVERIFY(list.contains("Circle") == true);
-    QVERIFY(list.contains("Eight") == true);
-    QVERIFY(list.contains("Line") == true);
-    QVERIFY(list.contains("Diamond") == true);
-    QVERIFY(list.contains("Lissajous") == true);
+    QCOMPARE(list.size(), 5);
+    QVERIFY(list.contains("Circle"));
+    QVERIFY(list.contains("Eight"));
+    QVERIFY(list.contains("Line"));
+    QVERIFY(list.contains("Diamond"));
+    QVERIFY(list.contains("Lissajous"));

     EFX e(m_doc);

     /* All EFX's have Circle as the initial algorithm */
-    QVERIFY(e.algorithm() == EFX::Circle);
+    QCOMPARE(e.algorithm(), EFX::Circle);

     e.setAlgorithm(EFX::Eight);
-    QVERIFY(e.algorithm() == EFX::Eight);
+    QCOMPARE(e.algorithm(), EFX::Eight);

     e.setAlgorithm(EFX::Line);
-    QVERIFY(e.algorithm() == EFX::Line);
+    QCOMPARE(e.algorithm(), EFX::Line);

     e.setAlgorithm(EFX::Diamond);
-    QVERIFY(e.algorithm() == EFX::Diamond);
+    QCOMPARE(e.algorithm(), EFX::Diamond);

     e.setAlgorithm(EFX::Lissajous);
-    QVERIFY(e.algorithm() == EFX::Lissajous);
+    QCOMPARE(e.algorithm(), EFX::Lissajous);

     /* Invalid algorithm results in Circle as a fallback */
     e.setAlgorithm(EFX::Algorithm(31337));
-    QVERIFY(e.algorithm() == EFX::Circle);
+    QCOMPARE(e.algorithm(), EFX::Circle);
 }

 void EFX_Test::stringToAlgorithm()
@@ -145,19 +145,19 @@
     EFX e(m_doc);

     e.setWidth(300);
-    QVERIFY(e.width() == 127);
+    QCOMPARE(e.width(), 127);

     e.setWidth(0);
-    QVERIFY(e.width() == 0);
+    QCOMPARE(e.width(), 0);

     e.setWidth(128);
-    QVERIFY(e.width() == 127);
+    QCOMPARE(e.width(), 127);

     e.setWidth(52);
-    QVERIFY(e.width() == 52);
+    QCOMPARE(e.width(), 52);

     e.setWidth(-4);
-    QVERIFY(e.width() == 0);
+    QCOMPARE(e.width(), 0);
 }

 void EFX_Test::height()
@@ -165,19 +165,19 @@
     EFX e(m_doc);

     e.setHeight(300);
-    QVERIFY(e.height() == 127);
+    QCOMPARE(e.height(), 127);

     e.setHeight(0);
-    QVERIFY(e.height() == 0);
+    QCOMPARE(e.height(), 0);

     e.setHeight(128);
-    QVERIFY(e.height() == 127);
+    QCOMPARE(e.height(), 127);

     e.setHeight(12);
-    QVERIFY(e.height() == 12);
+    QCOMPARE(e.height(), 12);

     e.setHeight(-4);
-    QVERIFY(e.height() == 0);
+    QCOMPARE(e.height(), 0);
 }

 void EFX_Test::rotation()
@@ -187,27 +187,27 @@
     QCOMPARE(e.m_sinR, sin(M_PI/180 * 0));

     e.setRotation(400);
-    QVERIFY(e.rotation() == 359);
+    QCOMPARE(e.rotation(), 359);
     QCOMPARE(e.m_cosR, cos(M_PI/180 * 359));
     QCOMPARE(e.m_sinR, sin(M_PI/180 * 359));

     e.setRotation(360);
-    QVERIFY(e.rotation() == 359);
+    QCOMPARE(e.rotation(), 359);
     QCOMPARE(e.m_cosR, cos(M_PI/180 * 359));
     QCOMPARE(e.m_sinR, sin(M_PI/180 * 359));

     e.setRotation(0);
-    QVERIFY(e.rotation() == 0);
+    QCOMPARE(e.rotation(), 0);
     QCOMPARE(e.m_cosR, cos(M_PI/180 * 0));
     QCOMPARE(e.m_sinR, sin(M_PI/180 * 0));

     e.setRotation(12);
-    QVERIFY(e.rotation() == 12);
+    QCOMPARE(e.rotation(), 12);
     QCOMPARE(e.m_cosR, cos(M_PI/180 * 12));
     QCOMPARE(e.m_sinR, sin(M_PI/180 * 12));

     e.setRotation(-4);
-    QVERIFY(e.rotation() == 0);
+    QCOMPARE(e.rotation(), 0);
     QCOMPARE(e.m_cosR, cos(M_PI/180 * 0));
     QCOMPARE(e.m_sinR, sin(M_PI/180 * 0));
 }
@@ -217,19 +217,19 @@
     EFX e(m_doc);

     e.setXOffset(300);
-    QVERIFY(e.xOffset() == UCHAR_MAX);
+    QCOMPARE(e.xOffset(), UCHAR_MAX);

     e.setXOffset(0);
-    QVERIFY(e.xOffset() == 0);
+    QCOMPARE(e.xOffset(), 0);

     e.setXOffset(256);
-    QVERIFY(e.xOffset() == UCHAR_MAX);
+    QCOMPARE(e.xOffset(), UCHAR_MAX);

     e.setXOffset(12);
-    QVERIFY(e.xOffset() == 12);
+    QCOMPARE(e.xOffset(), 12);

     e.setXOffset(-4);
-    QVERIFY(e.xOffset() == 0);
+    QCOMPARE(e.xOffset(), 0);
 }

 void EFX_Test::yOffset()
@@ -237,290 +237,290 @@
     EFX e(m_doc);

     e.setYOffset(300);
-    QVERIFY(e.yOffset() == UCHAR_MAX);
+    QCOMPARE(e.yOffset(), UCHAR_MAX);

     e.setYOffset(0);
-    QVERIFY(e.yOffset() == 0);
+    QCOMPARE(e.yOffset(), 0);

     e.setYOffset(256);
-    QVERIFY(e.yOffset() == UCHAR_MAX);
+    QCOMPARE(e.yOffset(), UCHAR_MAX);

     e.setYOffset(12);
-    QVERIFY(e.yOffset() == 12);
+    QCOMPARE(e.yOffset(), 12);

     e.setYOffset(-4);
-    QVERIFY(e.yOffset() == 0);
+    QCOMPARE(e.yOffset(), 0);
 }

 void EFX_Test::xFrequency()
 {
     EFX e(m_doc);

-    QVERIFY(e.isFrequencyEnabled() == false);
+    QVERIFY(!e.isFrequencyEnabled());

     e.setXFrequency(10);
-    QVERIFY(e.xFrequency() == 5);
+    QCOMPARE(e.xFrequency(), 5);

     e.setXFrequency(6);
-    QVERIFY(e.xFrequency() == 5);
+    QCOMPARE(e.xFrequency(), 5);

     e.setXFrequency(0);
-    QVERIFY(e.xFrequency() == 0);
+    QCOMPARE(e.xFrequency(), 0);

     e.setXFrequency(3);
-    QVERIFY(e.xFrequency() == 3);
+    QCOMPARE(e.xFrequency(), 3);

     e.setXFrequency(-4);
-    QVERIFY(e.xFrequency() == 0);
+    QCOMPARE(e.xFrequency(), 0);

     e.setAlgorithm(EFX::Lissajous);
-    QVERIFY(e.isFrequencyEnabled() == true);
+    QVERIFY(e.isFrequencyEnabled());

     e.setXFrequency(10);
-    QVERIFY(e.xFrequency() == 5);
+    QCOMPARE(e.xFrequency(), 5);

     e.setXFrequency(6);
-    QVERIFY(e.xFrequency() == 5);
+    QCOMPARE(e.xFrequency(), 5);

     e.setXFrequency(0);
-    QVERIFY(e.xFrequency() == 0);
+    QCOMPARE(e.xFrequency(), 0);

     e.setXFrequency(3);
-    QVERIFY(e.xFrequency() == 3);
+    QCOMPARE(e.xFrequency(), 3);

     e.setXFrequency(-4);
-    QVERIFY(e.xFrequency() == 0);
+    QCOMPARE(e.xFrequency(), 0);
 }

 void EFX_Test::yFrequency()
 {
     EFX e(m_doc);

-    QVERIFY(e.isFrequencyEnabled() == false);
+    QVERIFY(!e.isFrequencyEnabled());

     e.setYFrequency(10);
-    QVERIFY(e.yFrequency() == 5);
+    QCOMPARE(e.yFrequency(), 5);

     e.setYFrequency(6);
-    QVERIFY(e.yFrequency() == 5);
+    QCOMPARE(e.yFrequency(), 5);

     e.setYFrequency(0);
-    QVERIFY(e.yFrequency() == 0);
+    QCOMPARE(e.yFrequency(), 0);

     e.setYFrequency(3);
-    QVERIFY(e.yFrequency() == 3);
+    QCOMPARE(e.yFrequency(), 3);

     e.setYFrequency(-4);
-    QVERIFY(e.yFrequency() == 0);
+    QCOMPARE(e.yFrequency(), 0);

     e.setAlgorithm(EFX::Lissajous);
-    QVERIFY(e.isFrequencyEnabled() == true);
+    QVERIFY(e.isFrequencyEnabled());

     e.setXFrequency(10);
-    QVERIFY(e.xFrequency() == 5);
+    QCOMPARE(e.xFrequency(), 5);

     e.setXFrequency(6);
-    QVERIFY(e.xFrequency() == 5);
+    QCOMPARE(e.xFrequency(), 5);

     e.setXFrequency(0);
-    QVERIFY(e.xFrequency() == 0);
+    QCOMPARE(e.xFrequency(), 0);

     e.setXFrequency(3);
-    QVERIFY(e.xFrequency() == 3);
+    QCOMPARE(e.xFrequency(), 3);

     e.setXFrequency(-4);
-    QVERIFY(e.xFrequency() == 0);
+    QCOMPARE(e.xFrequency(), 0);
 }

 void EFX_Test::xPhase()
 {
     EFX e(m_doc);

-    QVERIFY(e.isPhaseEnabled() == false);
+    QVERIFY(!e.isPhaseEnabled());

     e.setXPhase(400);
-    QVERIFY(e.xPhase() == 359);
+    QCOMPARE(e.xPhase(), 359);

     e.setXPhase(360);
-    QVERIFY(e.xPhase() == 359);
+    QCOMPARE(e.xPhase(), 359);

     e.setXPhase(0);
-    QVERIFY(e.xPhase() == 0);
+    QCOMPARE(e.xPhase(), 0);

     e.setXPhase(359);
-    QVERIFY(e.xPhase() == 359);
+    QCOMPARE(e.xPhase(), 359);

     e.setXPhase(46);
-    QVERIFY(e.xPhase() == 46);
+    QCOMPARE(e.xPhase(), 46);

     e.setXPhase(-4);
-    QVERIFY(e.xPhase() == 0);
+    QCOMPARE(e.xPhase(), 0);

     e.setAlgorithm(EFX::Lissajous);
-    QVERIFY(e.isPhaseEnabled() == true);
+    QVERIFY(e.isPhaseEnabled());

     e.setXPhase(400);
-    QVERIFY(e.xPhase() == 359);
+    QCOMPARE(e.xPhase(), 359);

     e.setXPhase(360);
-    QVERIFY(e.xPhase() == 359);
+    QCOMPARE(e.xPhase(), 359);

     e.setXPhase(0);
-    QVERIFY(e.xPhase() == 0);
+    QCOMPARE(e.xPhase(), 0);

     e.setXPhase(359);
-    QVERIFY(e.xPhase() == 359);
+    QCOMPARE(e.xPhase(), 359);

     e.setXPhase(46);
-    QVERIFY(e.xPhase() == 46);
+    QCOMPARE(e.xPhase(), 46);

     e.setXPhase(-4);
-    QVERIFY(e.xPhase() == 0);
+    QCOMPARE(e.xPhase(), 0);
 }

 void EFX_Test::yPhase()
 {
     EFX e(m_doc);

-    QVERIFY(e.isPhaseEnabled() == false);
+    QVERIFY(!e.isPhaseEnabled());

     e.setYPhase(400);
-    QVERIFY(e.yPhase() == 359);
+    QCOMPARE(e.yPhase(), 359);

     e.setYPhase(360);
-    QVERIFY(e.yPhase() == 359);
+    QCOMPARE(e.yPhase(), 359);

     e.setYPhase(0);
-    QVERIFY(e.yPhase() == 0);
+    QCOMPARE(e.yPhase(), 0);

     e.setYPhase(359);
-    QVERIFY(e.yPhase() == 359);
+    QCOMPARE(e.yPhase(), 359);

     e.setYPhase(152);
-    QVERIFY(e.yPhase() == 152);
+    QCOMPARE(e.yPhase(), 152);

     e.setYPhase(-4);
-    QVERIFY(e.yPhase() == 0);
+    QCOMPARE(e.yPhase(), 0);

     e.setAlgorithm(EFX::Lissajous);
-    QVERIFY(e.isPhaseEnabled() == true);
+    QVERIFY(e.isPhaseEnabled());

     e.setYPhase(400);
-    QVERIFY(e.yPhase() == 359);
+    QCOMPARE(e.yPhase(), 359);

     e.setYPhase(360);
-    QVERIFY(e.yPhase() == 359);
+    QCOMPARE(e.yPhase(), 359);

     e.setYPhase(0);
-    QVERIFY(e.yPhase() == 0);
+    QCOMPARE(e.yPhase(), 0);

     e.setYPhase(359);
-    QVERIFY(e.yPhase() == 359);
+    QCOMPARE(e.yPhase(), 359);

     e.setYPhase(152);
-    QVERIFY(e.yPhase() == 152);
+    QCOMPARE(e.yPhase(), 152);

     e.setYPhase(-4);
-    QVERIFY(e.yPhase() == 0);
+    QCOMPARE(e.yPhase(), 0);
 }

 void EFX_Test::fixtures()
 {
     EFX* e = new EFX(m_doc);
-    QVERIFY(e->fixtures().size() == 0);
+    QCOMPARE(e->fixtures().size(), 0);

     /* Add first fixture */
     EFXFixture* ef1 = new EFXFixture(e);
     ef1->setFixture(12);
-    QVERIFY(e->addFixture(ef1) == true);
-    QVERIFY(e->fixtures().size() == 1);
+    QVERIFY(e->addFixture(ef1));
+    QCOMPARE(e->fixtures().size(), 1);

     /* Add second fixture */
     EFXFixture* ef2 = new EFXFixture(e);
     ef2->setFixture(34);
-    QVERIFY(e->addFixture(ef2) == true);
-    QVERIFY(e->fixtures().size() == 2);
+    QVERIFY(e->addFixture(ef2));
+    QCOMPARE(e->fixtures().size(), 2);

     /* Must not be able to add the same fixture twice */
-    QVERIFY(e->addFixture(ef1) == false);
-    QVERIFY(e->addFixture(ef2) == false);
-    QVERIFY(e->fixtures().size() == 2);
+    QVERIFY(!e->addFixture(ef1));
+    QVERIFY(!e->addFixture(ef2));
+    QCOMPARE(e->fixtures().size(), 2);

     /* Try to remove a non-member fixture */
     EFXFixture* ef3 = new EFXFixture(e);
     ef3->setFixture(56);
-    QVERIFY(e->removeFixture(ef3) == false);
-    QVERIFY(e->fixtures().size() == 2);
+    QVERIFY(!e->removeFixture(ef3));
+    QCOMPARE(e->fixtures().size(), 2);

     /* Add third fixture */
     e->addFixture(ef3);
-    QVERIFY(e->fixtures().size() == 3);
-    QVERIFY(e->fixtures().at(0) == ef1);
-    QVERIFY(e->fixtures().at(1) == ef2);
-    QVERIFY(e->fixtures().at(2) == ef3);
+    QCOMPARE(e->fixtures().size(), 3);
+    QCOMPARE(e->fixtures().at(0), ef1);
+    QCOMPARE(e->fixtures().at(1), ef2);
+    QCOMPARE(e->fixtures().at(2), ef3);

     /* Add fourth fixture */
     EFXFixture* ef4 = new EFXFixture(e);
     ef4->setFixture(78);
     e->addFixture(ef4);
-    QVERIFY(e->fixtures().size() == 4);
-    QVERIFY(e->fixtures().at(0) == ef1);
-    QVERIFY(e->fixtures().at(1) == ef2);
-    QVERIFY(e->fixtures().at(2) == ef3);
-    QVERIFY(e->fixtures().at(3) == ef4);
-
-    QVERIFY(e->removeFixture(ef4) == true);
-    QVERIFY(e->fixtures().at(0) == ef1);
-    QVERIFY(e->fixtures().at(1) == ef2);
-    QVERIFY(e->fixtures().at(2) == ef3);
+    QCOMPARE(e->fixtures().size(), 4);
+    QCOMPARE(e->fixtures().at(0), ef1);
+    QCOMPARE(e->fixtures().at(1), ef2);
+    QCOMPARE(e->fixtures().at(2), ef3);
+    QCOMPARE(e->fixtures().at(3), ef4);
+
+    QVERIFY(e->removeFixture(ef4));
+    QCOMPARE(e->fixtures().at(0), ef1);
+    QCOMPARE(e->fixtures().at(1), ef2);
+    QCOMPARE(e->fixtures().at(2), ef3);
     delete ef4;

     /* Raising the first and lowering the last must not succeed */
-    QVERIFY(e->raiseFixture(ef1) == false);
-    QVERIFY(e->lowerFixture(ef3) == false);
-    QVERIFY(e->fixtures().at(0) == ef1);
-    QVERIFY(e->fixtures().at(1) == ef2);
-    QVERIFY(e->fixtures().at(2) == ef3);
-
-    QVERIFY(e->raiseFixture(ef2) == true);
-    QVERIFY(e->fixtures().at(0) == ef2);
-    QVERIFY(e->fixtures().at(1) == ef1);
-    QVERIFY(e->fixtures().at(2) == ef3);
-    QVERIFY(e->raiseFixture(ef2) == false);
-
-    QVERIFY(e->lowerFixture(ef1) == true);
-    QVERIFY(e->fixtures().at(0) == ef2);
-    QVERIFY(e->fixtures().at(1) == ef3);
-    QVERIFY(e->fixtures().at(2) == ef1);
-    QVERIFY(e->lowerFixture(ef1) == false);
+    QVERIFY(!e->raiseFixture(ef1));
+    QVERIFY(!e->lowerFixture(ef3));
+    QCOMPARE(e->fixtures().at(0), ef1);
+    QCOMPARE(e->fixtures().at(1), ef2);
+    QCOMPARE(e->fixtures().at(2), ef3);
+
+    QVERIFY(e->raiseFixture(ef2));
+    QCOMPARE(e->fixtures().at(0), ef2);
+    QCOMPARE(e->fixtures().at(1), ef1);
+    QCOMPARE(e->fixtures().at(2), ef3);
+    QVERIFY(!e->raiseFixture(ef2));
+
+    QVERIFY(e->lowerFixture(ef1));
+    QCOMPARE(e->fixtures().at(0), ef2);
+    QCOMPARE(e->fixtures().at(1), ef3);
+    QCOMPARE(e->fixtures().at(2), ef1);
+    QVERIFY(!e->lowerFixture(ef1));

     /* Uninteresting fixture is removed */
     e->slotFixtureRemoved(99);
-    QVERIFY(e->fixtures().size() == 3);
-    QVERIFY(e->fixtures().at(0) == ef2);
-    QVERIFY(e->fixtures().at(1) == ef3);
-    QVERIFY(e->fixtures().at(2) == ef1);
+    QCOMPARE(e->fixtures().size(), 3);
+    QCOMPARE(e->fixtures().at(0), ef2);
+    QCOMPARE(e->fixtures().at(1), ef3);
+    QCOMPARE(e->fixtures().at(2), ef1);

     /* Member fixture is removed */
     e->slotFixtureRemoved(34);
-    QVERIFY(e->fixtures().size() == 2);
-    QVERIFY(e->fixtures().at(0) == ef3);
-    QVERIFY(e->fixtures().at(1) == ef1);
+    QCOMPARE(e->fixtures().size(), 2);
+    QCOMPARE(e->fixtures().at(0), ef3);
+    QCOMPARE(e->fixtures().at(1), ef1);

     /* Non-Member fixture is removed */
     e->slotFixtureRemoved(34);
-    QVERIFY(e->fixtures().size() == 2);
-    QVERIFY(e->fixtures().at(0) == ef3);
-    QVERIFY(e->fixtures().at(1) == ef1);
+    QCOMPARE(e->fixtures().size(), 2);
+    QCOMPARE(e->fixtures().at(0), ef3);
+    QCOMPARE(e->fixtures().at(1), ef1);

     /* Member fixture is removed */
     e->slotFixtureRemoved(12);
-    QVERIFY(e->fixtures().size() == 1);
-    QVERIFY(e->fixtures().at(0) == ef3);
+    QCOMPARE(e->fixtures().size(), 1);
+    QCOMPARE(e->fixtures().at(0), ef3);

     /* Member fixture is removed */
     e->slotFixtureRemoved(56);
-    QVERIFY(e->fixtures().size() == 0);
+    QCOMPARE(e->fixtures().size(), 0);

     delete e;
 }
@@ -528,23 +528,23 @@
 void EFX_Test::propagationMode()
 {
     EFX e(m_doc);
-    QVERIFY(e.propagationMode() == EFX::Parallel);
+    QCOMPARE(e.propagationMode(), EFX::Parallel);

     e.setPropagationMode(EFX::Serial);
-    QVERIFY(e.propagationMode() == EFX::Serial);
+    QCOMPARE(e.propagationMode(), EFX::Serial);

     e.setPropagationMode(EFX::Asymmetric);
-    QVERIFY(e.propagationMode() == EFX::Asymmetric);
-
-    QVERIFY(EFX::propagationModeToString(EFX::Serial) == "Serial");
-    QVERIFY(EFX::propagationModeToString(EFX::Parallel) == "Parallel");
-    QVERIFY(EFX::propagationModeToString(EFX::Asymmetric) == "Asymmetric");
-    QVERIFY(EFX::propagationModeToString(EFX::PropagationMode(7)) == "Parallel");
-
-    QVERIFY(EFX::stringToPropagationMode("Serial") == EFX::Serial);
-    QVERIFY(EFX::stringToPropagationMode("Parallel") == EFX::Parallel);
-    QVERIFY(EFX::stringToPropagationMode("Asymmetric") == EFX::Asymmetric);
-    QVERIFY(EFX::stringToPropagationMode("Foobar") == EFX::Parallel);
+    QCOMPARE(e.propagationMode(), EFX::Asymmetric);
+
+    QCOMPARE(EFX::propagationModeToString(EFX::Serial), QString("Serial"));
+    QCOMPARE(EFX::propagationModeToString(EFX::Parallel), QString("Parallel"));
+    QCOMPARE(EFX::propagationModeToString(EFX::Asymmetric), QString("Asymmetric"));
+    QCOMPARE(EFX::propagationModeToString(EFX::PropagationMode(7)), QString("Parallel"));
+
+    QCOMPARE(EFX::stringToPropagationMode("Serial"), EFX::Serial);
+    QCOMPARE(EFX::stringToPropagationMode("Parallel"), EFX::Parallel);
+    QCOMPARE(EFX::stringToPropagationMode("Asymmetric"), EFX::Asymmetric);
+    QCOMPARE(EFX::stringToPropagationMode("Foobar"), EFX::Parallel);
 }

 void EFX_Test::previewCircle()
@@ -552,137 +552,137 @@
     EFX e(m_doc);

     QVector <QPoint> poly;
-    QVERIFY(e.preview(Function::Forward, poly) == true);
-    QVERIFY(poly.size() == 128);
-
-    QVERIFY(poly[0] == QPoint(127,254));
-    QVERIFY(poly[1] == QPoint(120,253));
-    QVERIFY(poly[2] == QPoint(114,253));
-    QVERIFY(poly[3] == QPoint(108,252));
-    QVERIFY(poly[4] == QPoint(102,251));
-    QVERIFY(poly[5] == QPoint(96,250));
-    QVERIFY(poly[6] == QPoint(90,248));
-    QVERIFY(poly[7] == QPoint(84,246));
-    QVERIFY(poly[8] == QPoint(78,244));
-    QVERIFY(poly[9] == QPoint(72,241));
-    QVERIFY(poly[10] == QPoint(67,239));
-    QVERIFY(poly[11] == QPoint(61,235));
-    QVERIFY(poly[12] == QPoint(56,232));
-    QVERIFY(poly[13] == QPoint(51,229));
-    QVERIFY(poly[14] == QPoint(46,225));
-    QVERIFY(poly[15] == QPoint(41,221));
-    QVERIFY(poly[16] == QPoint(37,216));
-    QVERIFY(poly[17] == QPoint(32,212));
-    QVERIFY(poly[18] == QPoint(28,207));
-    QVERIFY(poly[19] == QPoint(24,202));
-    QVERIFY(poly[20] == QPoint(21,197));
-    QVERIFY(poly[21] == QPoint(18,192));
-    QVERIFY(poly[22] == QPoint(14,186));
-    QVERIFY(poly[23] == QPoint(12,181));
-    QVERIFY(poly[24] == QPoint(9,175));
-    QVERIFY(poly[25] == QPoint(7,169));
-    QVERIFY(poly[26] == QPoint(5,163));
-    QVERIFY(poly[27] == QPoint(3,157));
-    QVERIFY(poly[28] == QPoint(2,151));
-    QVERIFY(poly[29] == QPoint(1,145));
-    QVERIFY(poly[30] == QPoint(0,139));
-    QVERIFY(poly[31] == QPoint(0,133));
-    QVERIFY(poly[32] == QPoint(0,126));
-    QVERIFY(poly[33] == QPoint(0,120));
-    QVERIFY(poly[34] == QPoint(0,114));
-    QVERIFY(poly[35] == QPoint(1,108));
-    QVERIFY(poly[36] == QPoint(2,102));
-    QVERIFY(poly[37] == QPoint(3,96));
-    QVERIFY(poly[38] == QPoint(5,90));
-    QVERIFY(poly[39] == QPoint(7,84));
-    QVERIFY(poly[40] == QPoint(9,78));
-    QVERIFY(poly[41] == QPoint(12,72));
-    QVERIFY(poly[42] == QPoint(14,67));
-    QVERIFY(poly[43] == QPoint(18,61));
-    QVERIFY(poly[44] == QPoint(21,56));
-    QVERIFY(poly[45] == QPoint(24,51));
-    QVERIFY(poly[46] == QPoint(28,46));
-    QVERIFY(poly[47] == QPoint(32,41));
-    QVERIFY(poly[48] == QPoint(37,37));
-    QVERIFY(poly[49] == QPoint(41,32));
-    QVERIFY(poly[50] == QPoint(46,28));
-    QVERIFY(poly[51] == QPoint(51,24));
-    QVERIFY(poly[52] == QPoint(56,21));
-    QVERIFY(poly[53] == QPoint(61,18));
-    QVERIFY(poly[54] == QPoint(67,14));
-    QVERIFY(poly[55] == QPoint(72,12));
-    QVERIFY(poly[56] == QPoint(78,9));
-    QVERIFY(poly[57] == QPoint(84,7));
-    QVERIFY(poly[58] == QPoint(90,5));
-    QVERIFY(poly[59] == QPoint(96,3));
-    QVERIFY(poly[60] == QPoint(102,2));
-    QVERIFY(poly[61] == QPoint(108,1));
-    QVERIFY(poly[62] == QPoint(114,0));
-    QVERIFY(poly[63] == QPoint(120,0));
-    QVERIFY(poly[64] == QPoint(126,0));
-    QVERIFY(poly[65] == QPoint(133,0));
-    QVERIFY(poly[66] == QPoint(139,0));
-    QVERIFY(poly[67] == QPoint(145,1));
-    QVERIFY(poly[68] == QPoint(151,2));
-    QVERIFY(poly[69] == QPoint(157,3));
-    QVERIFY(poly[70] == QPoint(163,5));
-    QVERIFY(poly[71] == QPoint(169,7));
-    QVERIFY(poly[72] == QPoint(175,9));
-    QVERIFY(poly[73] == QPoint(181,12));
-    QVERIFY(poly[74] == QPoint(186,14));
-    QVERIFY(poly[75] == QPoint(192,18));
-    QVERIFY(poly[76] == QPoint(197,21));
-    QVERIFY(poly[77] == QPoint(202,24));
-    QVERIFY(poly[78] == QPoint(207,28));
-    QVERIFY(poly[79] == QPoint(212,32));
-    QVERIFY(poly[80] == QPoint(216,37));
-    QVERIFY(poly[81] == QPoint(221,41));
-    QVERIFY(poly[82] == QPoint(225,46));
-    QVERIFY(poly[83] == QPoint(229,51));
-    QVERIFY(poly[84] == QPoint(232,56));
-    QVERIFY(poly[85] == QPoint(235,61));
-    QVERIFY(poly[86] == QPoint(239,67));
-    QVERIFY(poly[87] == QPoint(241,72));
-    QVERIFY(poly[88] == QPoint(244,78));
-    QVERIFY(poly[89] == QPoint(246,84));
-    QVERIFY(poly[90] == QPoint(248,90));
-    QVERIFY(poly[91] == QPoint(250,96));
-    QVERIFY(poly[92] == QPoint(251,102));
-    QVERIFY(poly[93] == QPoint(252,108));
-    QVERIFY(poly[94] == QPoint(253,114));
-    QVERIFY(poly[95] == QPoint(253,120));
-    QVERIFY(poly[96] == QPoint(254,126));
-    QVERIFY(poly[97] == QPoint(253,133));
-    QVERIFY(poly[98] == QPoint(253,139));
-    QVERIFY(poly[99] == QPoint(252,145));
-    QVERIFY(poly[100] == QPoint(251,151));
-    QVERIFY(poly[101] == QPoint(250,157));
-    QVERIFY(poly[102] == QPoint(248,163));
-    QVERIFY(poly[103] == QPoint(246,169));
-    QVERIFY(poly[104] == QPoint(244,175));
-    QVERIFY(poly[105] == QPoint(241,181));
-    QVERIFY(poly[106] == QPoint(239,186));
-    QVERIFY(poly[107] == QPoint(235,192));
-    QVERIFY(poly[108] == QPoint(232,197));
-    QVERIFY(poly[109] == QPoint(229,202));
-    QVERIFY(poly[110] == QPoint(225,207));
-    QVERIFY(poly[111] == QPoint(221,212));
-    QVERIFY(poly[112] == QPoint(216,216));
-    QVERIFY(poly[113] == QPoint(212,221));
-    QVERIFY(poly[114] == QPoint(207,225));
-    QVERIFY(poly[115] == QPoint(202,229));
-    QVERIFY(poly[116] == QPoint(197,232));
-    QVERIFY(poly[117] == QPoint(192,235));
-    QVERIFY(poly[118] == QPoint(186,239));
-    QVERIFY(poly[119] == QPoint(181,241));
-    QVERIFY(poly[120] == QPoint(175,244));
-    QVERIFY(poly[121] == QPoint(169,246));
-    QVERIFY(poly[122] == QPoint(163,248));
-    QVERIFY(poly[123] == QPoint(157,250));
-    QVERIFY(poly[124] == QPoint(151,251));
-    QVERIFY(poly[125] == QPoint(145,252));
-    QVERIFY(poly[126] == QPoint(139,253));
-    QVERIFY(poly[127] == QPoint(133,253));
+    QVERIFY(e.preview(Function::Forward, poly));
+    QCOMPARE(poly.size(), 128);
+
+    QCOMPARE(poly[0], QPoint(127,254));
+    QCOMPARE(poly[1], QPoint(120,253));
+    QCOMPARE(poly[2], QPoint(114,253));
+    QCOMPARE(poly[3], QPoint(108,252));
+    QCOMPARE(poly[4], QPoint(102,251));
+    QCOMPARE(poly[5], QPoint(96,250));
+    QCOMPARE(poly[6], QPoint(90,248));
+    QCOMPARE(poly[7], QPoint(84,246));
+    QCOMPARE(poly[8], QPoint(78,244));
+    QCOMPARE(poly[9], QPoint(72,241));
+    QCOMPARE(poly[10], QPoint(67,239));
+    QCOMPARE(poly[11], QPoint(61,235));
+    QCOMPARE(poly[12], QPoint(56,232));
+    QCOMPARE(poly[13], QPoint(51,229));
+    QCOMPARE(poly[14], QPoint(46,225));
+    QCOMPARE(poly[15], QPoint(41,221));
+    QCOMPARE(poly[16], QPoint(37,216));
+    QCOMPARE(poly[17], QPoint(32,212));
+    QCOMPARE(poly[18], QPoint(28,207));
+    QCOMPARE(poly[19], QPoint(24,202));
+    QCOMPARE(poly[20], QPoint(21,197));
+    QCOMPARE(poly[21], QPoint(18,192));
+    QCOMPARE(poly[22], QPoint(14,186));
+    QCOMPARE(poly[23], QPoint(12,181));
+    QCOMPARE(poly[24], QPoint(9,175));
+    QCOMPARE(poly[25], QPoint(7,169));
+    QCOMPARE(poly[26], QPoint(5,163));
+    QCOMPARE(poly[27], QPoint(3,157));
+    QCOMPARE(poly[28], QPoint(2,151));
+    QCOMPARE(poly[29], QPoint(1,145));
+    QCOMPARE(poly[30], QPoint(0,139));
+    QCOMPARE(poly[31], QPoint(0,133));
+    QCOMPARE(poly[32], QPoint(0,126));
+    QCOMPARE(poly[33], QPoint(0,120));
+    QCOMPARE(poly[34], QPoint(0,114));
+    QCOMPARE(poly[35], QPoint(1,108));
+    QCOMPARE(poly[36], QPoint(2,102));
+    QCOMPARE(poly[37], QPoint(3,96));
+    QCOMPARE(poly[38], QPoint(5,90));
+    QCOMPARE(poly[39], QPoint(7,84));
+    QCOMPARE(poly[40], QPoint(9,78));
+    QCOMPARE(poly[41], QPoint(12,72));
+    QCOMPARE(poly[42], QPoint(14,67));
+    QCOMPARE(poly[43], QPoint(18,61));
+    QCOMPARE(poly[44], QPoint(21,56));
+    QCOMPARE(poly[45], QPoint(24,51));
+    QCOMPARE(poly[46], QPoint(28,46));
+    QCOMPARE(poly[47], QPoint(32,41));
+    QCOMPARE(poly[48], QPoint(37,37));
+    QCOMPARE(poly[49], QPoint(41,32));
+    QCOMPARE(poly[50], QPoint(46,28));
+    QCOMPARE(poly[51], QPoint(51,24));
+    QCOMPARE(poly[52], QPoint(56,21));
+    QCOMPARE(poly[53], QPoint(61,18));
+    QCOMPARE(poly[54], QPoint(67,14));
+    QCOMPARE(poly[55], QPoint(72,12));
+    QCOMPARE(poly[56], QPoint(78,9));
+    QCOMPARE(poly[57], QPoint(84,7));
+    QCOMPARE(poly[58], QPoint(90,5));
+    QCOMPARE(poly[59], QPoint(96,3));
+    QCOMPARE(poly[60], QPoint(102,2));
+    QCOMPARE(poly[61], QPoint(108,1));
+    QCOMPARE(poly[62], QPoint(114,0));
+    QCOMPARE(poly[63], QPoint(120,0));
+    QCOMPARE(poly[64], QPoint(126,0));
+    QCOMPARE(poly[65], QPoint(133,0));
+    QCOMPARE(poly[66], QPoint(139,0));
+    QCOMPARE(poly[67], QPoint(145,1));
+    QCOMPARE(poly[68], QPoint(151,2));
+    QCOMPARE(poly[69], QPoint(157,3));
+    QCOMPARE(poly[70], QPoint(163,5));
+    QCOMPARE(poly[71], QPoint(169,7));
+    QCOMPARE(poly[72], QPoint(175,9));
+    QCOMPARE(poly[73], QPoint(181,12));
+    QCOMPARE(poly[74], QPoint(186,14));
+    QCOMPARE(poly[75], QPoint(192,18));
+    QCOMPARE(poly[76], QPoint(197,21));
+    QCOMPARE(poly[77], QPoint(202,24));
+    QCOMPARE(poly[78], QPoint(207,28));
+    QCOMPARE(poly[79], QPoint(212,32));
+    QCOMPARE(poly[80], QPoint(216,37));
+    QCOMPARE(poly[81], QPoint(221,41));
+    QCOMPARE(poly[82], QPoint(225,46));
+    QCOMPARE(poly[83], QPoint(229,51));
+    QCOMPARE(poly[84], QPoint(232,56));
+    QCOMPARE(poly[85], QPoint(235,61));
+    QCOMPARE(poly[86], QPoint(239,67));
+    QCOMPARE(poly[87], QPoint(241,72));
+    QCOMPARE(poly[88], QPoint(244,78));
+    QCOMPARE(poly[89], QPoint(246,84));
+    QCOMPARE(poly[90], QPoint(248,90));
+    QCOMPARE(poly[91], QPoint(250,96));
+    QCOMPARE(poly[92], QPoint(251,102));
+    QCOMPARE(poly[93], QPoint(252,108));
+    QCOMPARE(poly[94], QPoint(253,114));
+    QCOMPARE(poly[95], QPoint(253,120));
+    QCOMPARE(poly[96], QPoint(254,126));
+    QCOMPARE(poly[97], QPoint(253,133));
+    QCOMPARE(poly[98], QPoint(253,139));
+    QCOMPARE(poly[99], QPoint(252,145));
+    QCOMPARE(poly[100], QPoint(251,151));
+    QCOMPARE(poly[101], QPoint(250,157));
+    QCOMPARE(poly[102], QPoint(248,163));
+    QCOMPARE(poly[103], QPoint(246,169));
+    QCOMPARE(poly[104], QPoint(244,175));
+    QCOMPARE(poly[105], QPoint(241,181));
+    QCOMPARE(poly[106], QPoint(239,186));
+    QCOMPARE(poly[107], QPoint(235,192));
+    QCOMPARE(poly[108], QPoint(232,197));
+    QCOMPARE(poly[109], QPoint(229,202));
+    QCOMPARE(poly[110], QPoint(225,207));
+    QCOMPARE(poly[111], QPoint(221,212));
+    QCOMPARE(poly[112], QPoint(216,216));
+    QCOMPARE(poly[113], QPoint(212,221));
+    QCOMPARE(poly[114], QPoint(207,225));
+    QCOMPARE(poly[115], QPoint(202,229));
+    QCOMPARE(poly[116], QPoint(197,232));
+    QCOMPARE(poly[117], QPoint(192,235));
+    QCOMPARE(poly[118], QPoint(186,239));
+    QCOMPARE(poly[119], QPoint(181,241));
+    QCOMPARE(poly[120], QPoint(175,244));
+    QCOMPARE(poly[121], QPoint(169,246));
+    QCOMPARE(poly[122], QPoint(163,248));
+    QCOMPARE(poly[123], QPoint(157,250));
+    QCOMPARE(poly[124], QPoint(151,251));
+    QCOMPARE(poly[125], QPoint(145,252));
+    QCOMPARE(poly[126], QPoint(139,253));
+    QCOMPARE(poly[127], QPoint(133,253));
 }

 void EFX_Test::previewEight()
@@ -691,137 +691,137 @@
     e.setAlgorithm(EFX::Eight);

     QVector <QPoint> poly;
-    QVERIFY(e.preview(Function::Forward, poly) == true);
-    QVERIFY(poly.size() == 128);
-
-    QVERIFY(poly[0] == QPoint(127,254));
-    QVERIFY(poly[1] == QPoint(114,253));
-    QVERIFY(poly[2] == QPoint(102,253));
-    QVERIFY(poly[3] == QPoint(90,252));
-    QVERIFY(poly[4] == QPoint(78,251));
-    QVERIFY(poly[5] == QPoint(67,250));
-    QVERIFY(poly[6] == QPoint(56,248));
-    QVERIFY(poly[7] == QPoint(46,246));
-    QVERIFY(poly[8] == QPoint(37,244));
-    QVERIFY(poly[9] == QPoint(28,241));
-    QVERIFY(poly[10] == QPoint(21,239));
-    QVERIFY(poly[11] == QPoint(14,235));
-    QVERIFY(poly[12] == QPoint(9,232));
-    QVERIFY(poly[13] == QPoint(5,229));
-    QVERIFY(poly[14] == QPoint(2,225));
-    QVERIFY(poly[15] == QPoint(0,221));
-    QVERIFY(poly[16] == QPoint(0,216));
-    QVERIFY(poly[17] == QPoint(0,212));
-    QVERIFY(poly[18] == QPoint(2,207));
-    QVERIFY(poly[19] == QPoint(5,202));
-    QVERIFY(poly[20] == QPoint(9,197));
-    QVERIFY(poly[21] == QPoint(14,192));
-    QVERIFY(poly[22] == QPoint(21,186));
-    QVERIFY(poly[23] == QPoint(28,181));
-    QVERIFY(poly[24] == QPoint(37,175));
-    QVERIFY(poly[25] == QPoint(46,169));
-    QVERIFY(poly[26] == QPoint(56,163));
-    QVERIFY(poly[27] == QPoint(67,157));
-    QVERIFY(poly[28] == QPoint(78,151));
-    QVERIFY(poly[29] == QPoint(90,145));
-    QVERIFY(poly[30] == QPoint(102,139));
-    QVERIFY(poly[31] == QPoint(114,133));
-    QVERIFY(poly[32] == QPoint(127,126));
-    QVERIFY(poly[33] == QPoint(139,120));
-    QVERIFY(poly[34] == QPoint(151,114));
-    QVERIFY(poly[35] == QPoint(163,108));
-    QVERIFY(poly[36] == QPoint(175,102));
-    QVERIFY(poly[37] == QPoint(186,96));
-    QVERIFY(poly[38] == QPoint(197,90));
-    QVERIFY(poly[39] == QPoint(207,84));
-    QVERIFY(poly[40] == QPoint(216,78));
-    QVERIFY(poly[41] == QPoint(225,72));
-    QVERIFY(poly[42] == QPoint(232,67));
-    QVERIFY(poly[43] == QPoint(239,61));
-    QVERIFY(poly[44] == QPoint(244,56));
-    QVERIFY(poly[45] == QPoint(248,51));
-    QVERIFY(poly[46] == QPoint(251,46));
-    QVERIFY(poly[47] == QPoint(253,41));
-    QVERIFY(poly[48] == QPoint(254,37));
-    QVERIFY(poly[49] == QPoint(253,32));
-    QVERIFY(poly[50] == QPoint(251,28));
-    QVERIFY(poly[51] == QPoint(248,24));
-    QVERIFY(poly[52] == QPoint(244,21));
-    QVERIFY(poly[53] == QPoint(239,18));
-    QVERIFY(poly[54] == QPoint(232,14));
-    QVERIFY(poly[55] == QPoint(225,12));
-    QVERIFY(poly[56] == QPoint(216,9));
-    QVERIFY(poly[57] == QPoint(207,7));
-    QVERIFY(poly[58] == QPoint(197,5));
-    QVERIFY(poly[59] == QPoint(186,3));
-    QVERIFY(poly[60] == QPoint(175,2));
-    QVERIFY(poly[61] == QPoint(163,1));
-    QVERIFY(poly[62] == QPoint(151,0));
-    QVERIFY(poly[63] == QPoint(139,0));
-    QVERIFY(poly[64] == QPoint(127,0));
-    QVERIFY(poly[65] == QPoint(114,0));
-    QVERIFY(poly[66] == QPoint(102,0));
-    QVERIFY(poly[67] == QPoint(90,1));
-    QVERIFY(poly[68] == QPoint(78,2));
-    QVERIFY(poly[69] == QPoint(67,3));
-    QVERIFY(poly[70] == QPoint(56,5));
-    QVERIFY(poly[71] == QPoint(46,7));
-    QVERIFY(poly[72] == QPoint(37,9));
-    QVERIFY(poly[73] == QPoint(28,12));
-    QVERIFY(poly[74] == QPoint(21,14));
-    QVERIFY(poly[75] == QPoint(14,18));
-    QVERIFY(poly[76] == QPoint(9,21));
-    QVERIFY(poly[77] == QPoint(5,24));
-    QVERIFY(poly[78] == QPoint(2,28));
-    QVERIFY(poly[79] == QPoint(0,32));
-    QVERIFY(poly[80] == QPoint(0,37));
-    QVERIFY(poly[81] == QPoint(0,41));
-    QVERIFY(poly[82] == QPoint(2,46));
-    QVERIFY(poly[83] == QPoint(5,51));
-    QVERIFY(poly[84] == QPoint(9,56));
-    QVERIFY(poly[85] == QPoint(14,61));
-    QVERIFY(poly[86] == QPoint(21,67));
-    QVERIFY(poly[87] == QPoint(28,72));
-    QVERIFY(poly[88] == QPoint(37,78));
-    QVERIFY(poly[89] == QPoint(46,84));
-    QVERIFY(poly[90] == QPoint(56,90));
-    QVERIFY(poly[91] == QPoint(67,96));
-    QVERIFY(poly[92] == QPoint(78,102));
-    QVERIFY(poly[93] == QPoint(90,108));
-    QVERIFY(poly[94] == QPoint(102,114));
-    QVERIFY(poly[95] == QPoint(114,120));
-    QVERIFY(poly[96] == QPoint(126,126));
-    QVERIFY(poly[97] == QPoint(139,133));
-    QVERIFY(poly[98] == QPoint(151,139));
-    QVERIFY(poly[99] == QPoint(163,145));
-    QVERIFY(poly[100] == QPoint(175,151));
-    QVERIFY(poly[101] == QPoint(186,157));
-    QVERIFY(poly[102] == QPoint(197,163));
-    QVERIFY(poly[103] == QPoint(207,169));
-    QVERIFY(poly[104] == QPoint(216,175));
-    QVERIFY(poly[105] == QPoint(225,181));
-    QVERIFY(poly[106] == QPoint(232,186));
-    QVERIFY(poly[107] == QPoint(239,192));
-    QVERIFY(poly[108] == QPoint(244,197));
-    QVERIFY(poly[109] == QPoint(248,202));
-    QVERIFY(poly[110] == QPoint(251,207));
-    QVERIFY(poly[111] == QPoint(253,212));
-    QVERIFY(poly[112] == QPoint(254,216));
-    QVERIFY(poly[113] == QPoint(253,221));
-    QVERIFY(poly[114] == QPoint(251,225));
-    QVERIFY(poly[115] == QPoint(248,229));
-    QVERIFY(poly[116] == QPoint(244,232));
-    QVERIFY(poly[117] == QPoint(239,235));
-    QVERIFY(poly[118] == QPoint(232,239));
-    QVERIFY(poly[119] == QPoint(225,241));
-    QVERIFY(poly[120] == QPoint(216,244));
-    QVERIFY(poly[121] == QPoint(207,246));
-    QVERIFY(poly[122] == QPoint(197,248));
-    QVERIFY(poly[123] == QPoint(186,250));
-    QVERIFY(poly[124] == QPoint(175,251));
-    QVERIFY(poly[125] == QPoint(163,252));
-    QVERIFY(poly[126] == QPoint(151,253));
-    QVERIFY(poly[127] == QPoint(139,253));
+    QVERIFY(e.preview(Function::Forward, poly));
+    QCOMPARE(poly.size(), 128);
+
+    QCOMPARE(poly[0], QPoint(127,254));
+    QCOMPARE(poly[1], QPoint(114,253));
+    QCOMPARE(poly[2], QPoint(102,253));
+    QCOMPARE(poly[3], QPoint(90,252));
+    QCOMPARE(poly[4], QPoint(78,251));
+    QCOMPARE(poly[5], QPoint(67,250));
+    QCOMPARE(poly[6], QPoint(56,248));
+    QCOMPARE(poly[7], QPoint(46,246));
+    QCOMPARE(poly[8], QPoint(37,244));
+    QCOMPARE(poly[9], QPoint(28,241));
+    QCOMPARE(poly[10], QPoint(21,239));
+    QCOMPARE(poly[11], QPoint(14,235));
+    QCOMPARE(poly[12], QPoint(9,232));
+    QCOMPARE(poly[13], QPoint(5,229));
+    QCOMPARE(poly[14], QPoint(2,225));
+    QCOMPARE(poly[15], QPoint(0,221));
+    QCOMPARE(poly[16], QPoint(0,216));
+    QCOMPARE(poly[17], QPoint(0,212));
+    QCOMPARE(poly[18], QPoint(2,207));
+    QCOMPARE(poly[19], QPoint(5,202));
+    QCOMPARE(poly[20], QPoint(9,197));
+    QCOMPARE(poly[21], QPoint(14,192));
+    QCOMPARE(poly[22], QPoint(21,186));
+    QCOMPARE(poly[23], QPoint(28,181));
+    QCOMPARE(poly[24], QPoint(37,175));
+    QCOMPARE(poly[25], QPoint(46,169));
+    QCOMPARE(poly[26], QPoint(56,163));
+    QCOMPARE(poly[27], QPoint(67,157));
+    QCOMPARE(poly[28], QPoint(78,151));
+    QCOMPARE(poly[29], QPoint(90,145));
+    QCOMPARE(poly[30], QPoint(102,139));
+    QCOMPARE(poly[31], QPoint(114,133));
+    QCOMPARE(poly[32], QPoint(127,126));
+    QCOMPARE(poly[33], QPoint(139,120));
+    QCOMPARE(poly[34], QPoint(151,114));
+    QCOMPARE(poly[35], QPoint(163,108));
+    QCOMPARE(poly[36], QPoint(175,102));
+    QCOMPARE(poly[37], QPoint(186,96));
+    QCOMPARE(poly[38], QPoint(197,90));
+    QCOMPARE(poly[39], QPoint(207,84));
+    QCOMPARE(poly[40], QPoint(216,78));
+    QCOMPARE(poly[41], QPoint(225,72));
+    QCOMPARE(poly[42], QPoint(232,67));
+    QCOMPARE(poly[43], QPoint(239,61));
+    QCOMPARE(poly[44], QPoint(244,56));
+    QCOMPARE(poly[45], QPoint(248,51));
+    QCOMPARE(poly[46], QPoint(251,46));
+    QCOMPARE(poly[47], QPoint(253,41));
+    QCOMPARE(poly[48], QPoint(254,37));
+    QCOMPARE(poly[49], QPoint(253,32));
+    QCOMPARE(poly[50], QPoint(251,28));
+    QCOMPARE(poly[51], QPoint(248,24));
+    QCOMPARE(poly[52], QPoint(244,21));
+    QCOMPARE(poly[53], QPoint(239,18));
+    QCOMPARE(poly[54], QPoint(232,14));
+    QCOMPARE(poly[55], QPoint(225,12));
+    QCOMPARE(poly[56], QPoint(216,9));
+    QCOMPARE(poly[57], QPoint(207,7));
+    QCOMPARE(poly[58], QPoint(197,5));
+    QCOMPARE(poly[59], QPoint(186,3));
+    QCOMPARE(poly[60], QPoint(175,2));
+    QCOMPARE(poly[61], QPoint(163,1));
+    QCOMPARE(poly[62], QPoint(151,0));
+    QCOMPARE(poly[63], QPoint(139,0));
+    QCOMPARE(poly[64], QPoint(127,0));
+    QCOMPARE(poly[65], QPoint(114,0));
+    QCOMPARE(poly[66], QPoint(102,0));
+    QCOMPARE(poly[67], QPoint(90,1));
+    QCOMPARE(poly[68], QPoint(78,2));
+    QCOMPARE(poly[69], QPoint(67,3));
+    QCOMPARE(poly[70], QPoint(56,5));
+    QCOMPARE(poly[71], QPoint(46,7));
+    QCOMPARE(poly[72], QPoint(37,9));
+    QCOMPARE(poly[73], QPoint(28,12));
+    QCOMPARE(poly[74], QPoint(21,14));
+    QCOMPARE(poly[75], QPoint(14,18));
+    QCOMPARE(poly[76], QPoint(9,21));
+    QCOMPARE(poly[77], QPoint(5,24));
+    QCOMPARE(poly[78], QPoint(2,28));
+    QCOMPARE(poly[79], QPoint(0,32));
+    QCOMPARE(poly[80], QPoint(0,37));
+    QCOMPARE(poly[81], QPoint(0,41));
+    QCOMPARE(poly[82], QPoint(2,46));
+    QCOMPARE(poly[83], QPoint(5,51));
+    QCOMPARE(poly[84], QPoint(9,56));
+    QCOMPARE(poly[85], QPoint(14,61));
+    QCOMPARE(poly[86], QPoint(21,67));
+    QCOMPARE(poly[87], QPoint(28,72));
+    QCOMPARE(poly[88], QPoint(37,78));
+    QCOMPARE(poly[89], QPoint(46,84));
+    QCOMPARE(poly[90], QPoint(56,90));
+    QCOMPARE(poly[91], QPoint(67,96));
+    QCOMPARE(poly[92], QPoint(78,102));
+    QCOMPARE(poly[93], QPoint(90,108));
+    QCOMPARE(poly[94], QPoint(102,114));
+    QCOMPARE(poly[95], QPoint(114,120));
+    QCOMPARE(poly[96], QPoint(126,126));
+    QCOMPARE(poly[97], QPoint(139,133));
+    QCOMPARE(poly[98], QPoint(151,139));
+    QCOMPARE(poly[99], QPoint(163,145));
+    QCOMPARE(poly[100], QPoint(175,151));
+    QCOMPARE(poly[101], QPoint(186,157));
+    QCOMPARE(poly[102], QPoint(197,163));
+    QCOMPARE(poly[103], QPoint(207,169));
+    QCOMPARE(poly[104], QPoint(216,175));
+    QCOMPARE(poly[105], QPoint(225,181));
+    QCOMPARE(poly[106], QPoint(232,186));
+    QCOMPARE(poly[107], QPoint(239,192));
+    QCOMPARE(poly[108], QPoint(244,197));
+    QCOMPARE(poly[109], QPoint(248,202));
+    QCOMPARE(poly[110], QPoint(251,207));
+    QCOMPARE(poly[111], QPoint(253,212));
+    QCOMPARE(poly[112], QPoint(254,216));
+    QCOMPARE(poly[113], QPoint(253,221));
+    QCOMPARE(poly[114], QPoint(251,225));
+    QCOMPARE(poly[115], QPoint(248,229));
+    QCOMPARE(poly[116], QPoint(244,232));
+    QCOMPARE(poly[117], QPoint(239,235));
+    QCOMPARE(poly[118], QPoint(232,239));
+    QCOMPARE(poly[119], QPoint(225,241));
+    QCOMPARE(poly[120], QPoint(216,244));
+    QCOMPARE(poly[121], QPoint(207,246));
+    QCOMPARE(poly[122], QPoint(197,248));
+    QCOMPARE(poly[123], QPoint(186,250));
+    QCOMPARE(poly[124], QPoint(175,251));
+    QCOMPARE(poly[125], QPoint(163,252));
+    QCOMPARE(poly[126], QPoint(151,253));
+    QCOMPARE(poly[127], QPoint(139,253));
 }

 void EFX_Test::previewLine()
@@ -830,137 +830,137 @@
     e.setAlgorithm(EFX::Line);

     QVector <QPoint> poly;
-    QVERIFY(e.preview(Function::Forward, poly) == true);
-    QVERIFY(poly.size() == 128);
-
-    QVERIFY(poly[0] == QPoint(254,254));
-    QVERIFY(poly[1] == QPoint(253,253));
-    QVERIFY(poly[2] == QPoint(253,253));
-    QVERIFY(poly[3] == QPoint(252,252));
-    QVERIFY(poly[4] == QPoint(251,251));
-    QVERIFY(poly[5] == QPoint(250,250));
-    QVERIFY(poly[6] == QPoint(248,248));
-    QVERIFY(poly[7] == QPoint(246,246));
-    QVERIFY(poly[8] == QPoint(244,244));
-    QVERIFY(poly[9] == QPoint(241,241));
-    QVERIFY(poly[10] == QPoint(239,239));
-    QVERIFY(poly[11] == QPoint(235,235));
-    QVERIFY(poly[12] == QPoint(232,232));
-    QVERIFY(poly[13] == QPoint(229,229));
-    QVERIFY(poly[14] == QPoint(225,225));
-    QVERIFY(poly[15] == QPoint(221,221));
-    QVERIFY(poly[16] == QPoint(216,216));
-    QVERIFY(poly[17] == QPoint(212,212));
-    QVERIFY(poly[18] == QPoint(207,207));
-    QVERIFY(poly[19] == QPoint(202,202));
-    QVERIFY(poly[20] == QPoint(197,197));
-    QVERIFY(poly[21] == QPoint(192,192));
-    QVERIFY(poly[22] == QPoint(186,186));
-    QVERIFY(poly[23] == QPoint(181,181));
-    QVERIFY(poly[24] == QPoint(175,175));
-    QVERIFY(poly[25] == QPoint(169,169));
-    QVERIFY(poly[26] == QPoint(163,163));
-    QVERIFY(poly[27] == QPoint(157,157));
-    QVERIFY(poly[28] == QPoint(151,151));
-    QVERIFY(poly[29] == QPoint(145,145));
-    QVERIFY(poly[30] == QPoint(139,139));
-    QVERIFY(poly[31] == QPoint(133,133));
-    QVERIFY(poly[32] == QPoint(126,126));
-    QVERIFY(poly[33] == QPoint(120,120));
-    QVERIFY(poly[34] == QPoint(114,114));
-    QVERIFY(poly[35] == QPoint(108,108));
-    QVERIFY(poly[36] == QPoint(102,102));
-    QVERIFY(poly[37] == QPoint(96,96));
-    QVERIFY(poly[38] == QPoint(90,90));
-    QVERIFY(poly[39] == QPoint(84,84));
-    QVERIFY(poly[40] == QPoint(78,78));
-    QVERIFY(poly[41] == QPoint(72,72));
-    QVERIFY(poly[42] == QPoint(67,67));
-    QVERIFY(poly[43] == QPoint(61,61));
-    QVERIFY(poly[44] == QPoint(56,56));
-    QVERIFY(poly[45] == QPoint(51,51));
-    QVERIFY(poly[46] == QPoint(46,46));
-    QVERIFY(poly[47] == QPoint(41,41));
-    QVERIFY(poly[48] == QPoint(37,37));
-    QVERIFY(poly[49] == QPoint(32,32));
-    QVERIFY(poly[50] == QPoint(28,28));
-    QVERIFY(poly[51] == QPoint(24,24));
-    QVERIFY(poly[52] == QPoint(21,21));
-    QVERIFY(poly[53] == QPoint(18,18));
-    QVERIFY(poly[54] == QPoint(14,14));
-    QVERIFY(poly[55] == QPoint(12,12));
-    QVERIFY(poly[56] == QPoint(9,9));
-    QVERIFY(poly[57] == QPoint(7,7));
-    QVERIFY(poly[58] == QPoint(5,5));
-    QVERIFY(poly[59] == QPoint(3,3));
-    QVERIFY(poly[60] == QPoint(2,2));
-    QVERIFY(poly[61] == QPoint(1,1));
-    QVERIFY(poly[62] == QPoint(0,0));
-    QVERIFY(poly[63] == QPoint(0,0));
-    QVERIFY(poly[64] == QPoint(0,0));
-    QVERIFY(poly[65] == QPoint(0,0));
-    QVERIFY(poly[66] == QPoint(0,0));
-    QVERIFY(poly[67] == QPoint(1,1));
-    QVERIFY(poly[68] == QPoint(2,2));
-    QVERIFY(poly[69] == QPoint(3,3));
-    QVERIFY(poly[70] == QPoint(5,5));
-    QVERIFY(poly[71] == QPoint(7,7));
-    QVERIFY(poly[72] == QPoint(9,9));
-    QVERIFY(poly[73] == QPoint(12,12));
-    QVERIFY(poly[74] == QPoint(14,14));
-    QVERIFY(poly[75] == QPoint(18,18));
-    QVERIFY(poly[76] == QPoint(21,21));
-    QVERIFY(poly[77] == QPoint(24,24));
-    QVERIFY(poly[78] == QPoint(28,28));
-    QVERIFY(poly[79] == QPoint(32,32));
-    QVERIFY(poly[80] == QPoint(37,37));
-    QVERIFY(poly[81] == QPoint(41,41));
-    QVERIFY(poly[82] == QPoint(46,46));
-    QVERIFY(poly[83] == QPoint(51,51));
-    QVERIFY(poly[84] == QPoint(56,56));
-    QVERIFY(poly[85] == QPoint(61,61));
-    QVERIFY(poly[86] == QPoint(67,67));
-    QVERIFY(poly[87] == QPoint(72,72));
-    QVERIFY(poly[88] == QPoint(78,78));
-    QVERIFY(poly[89] == QPoint(84,84));
-    QVERIFY(poly[90] == QPoint(90,90));
-    QVERIFY(poly[91] == QPoint(96,96));
-    QVERIFY(poly[92] == QPoint(102,102));
-    QVERIFY(poly[93] == QPoint(108,108));
-    QVERIFY(poly[94] == QPoint(114,114));
-    QVERIFY(poly[95] == QPoint(120,120));
-    QVERIFY(poly[96] == QPoint(126,126));
-    QVERIFY(poly[97] == QPoint(133,133));
-    QVERIFY(poly[98] == QPoint(139,139));
-    QVERIFY(poly[99] == QPoint(145,145));
-    QVERIFY(poly[100] == QPoint(151,151));
-    QVERIFY(poly[101] == QPoint(157,157));
-    QVERIFY(poly[102] == QPoint(163,163));
-    QVERIFY(poly[103] == QPoint(169,169));
-    QVERIFY(poly[104] == QPoint(175,175));
-    QVERIFY(poly[105] == QPoint(181,181));
-    QVERIFY(poly[106] == QPoint(186,186));
-    QVERIFY(poly[107] == QPoint(192,192));
-    QVERIFY(poly[108] == QPoint(197,197));
-    QVERIFY(poly[109] == QPoint(202,202));
-    QVERIFY(poly[110] == QPoint(207,207));
-    QVERIFY(poly[111] == QPoint(212,212));
-    QVERIFY(poly[112] == QPoint(216,216));
-    QVERIFY(poly[113] == QPoint(221,221));
-    QVERIFY(poly[114] == QPoint(225,225));
-    QVERIFY(poly[115] == QPoint(229,229));
-    QVERIFY(poly[116] == QPoint(232,232));
-    QVERIFY(poly[117] == QPoint(235,235));
-    QVERIFY(poly[118] == QPoint(239,239));
-    QVERIFY(poly[119] == QPoint(241,241));
-    QVERIFY(poly[120] == QPoint(244,244));
-    QVERIFY(poly[121] == QPoint(246,246));
-    QVERIFY(poly[122] == QPoint(248,248));
-    QVERIFY(poly[123] == QPoint(250,250));
-    QVERIFY(poly[124] == QPoint(251,251));
-    QVERIFY(poly[125] == QPoint(252,252));
-    QVERIFY(poly[126] == QPoint(253,253));
-    QVERIFY(poly[127] == QPoint(253,253));
+    QVERIFY(e.preview(Function::Forward, poly));
+    QCOMPARE(poly.size(), 128);
+
+    QCOMPARE(poly[0], QPoint(254,254));
+    QCOMPARE(poly[1], QPoint(253,253));
+    QCOMPARE(poly[2], QPoint(253,253));
+    QCOMPARE(poly[3], QPoint(252,252));
+    QCOMPARE(poly[4], QPoint(251,251));
+    QCOMPARE(poly[5], QPoint(250,250));
+    QCOMPARE(poly[6], QPoint(248,248));
+    QCOMPARE(poly[7], QPoint(246,246));
+    QCOMPARE(poly[8], QPoint(244,244));
+    QCOMPARE(poly[9], QPoint(241,241));
+    QCOMPARE(poly[10], QPoint(239,239));
+    QCOMPARE(poly[11], QPoint(235,235));
+    QCOMPARE(poly[12], QPoint(232,232));
+    QCOMPARE(poly[13], QPoint(229,229));
+    QCOMPARE(poly[14], QPoint(225,225));
+    QCOMPARE(poly[15], QPoint(221,221));
+    QCOMPARE(poly[16], QPoint(216,216));
+    QCOMPARE(poly[17], QPoint(212,212));
+    QCOMPARE(poly[18], QPoint(207,207));
+    QCOMPARE(poly[19], QPoint(202,202));
+    QCOMPARE(poly[20], QPoint(197,197));
+    QCOMPARE(poly[21], QPoint(192,192));
+    QCOMPARE(poly[22], QPoint(186,186));
+    QCOMPARE(poly[23], QPoint(181,181));
+    QCOMPARE(poly[24], QPoint(175,175));
+    QCOMPARE(poly[25], QPoint(169,169));
+    QCOMPARE(poly[26], QPoint(163,163));
+    QCOMPARE(poly[27], QPoint(157,157));
+    QCOMPARE(poly[28], QPoint(151,151));
+    QCOMPARE(poly[29], QPoint(145,145));
+    QCOMPARE(poly[30], QPoint(139,139));
+    QCOMPARE(poly[31], QPoint(133,133));
+    QCOMPARE(poly[32], QPoint(126,126));
+    QCOMPARE(poly[33], QPoint(120,120));
+    QCOMPARE(poly[34], QPoint(114,114));
+    QCOMPARE(poly[35], QPoint(108,108));
+    QCOMPARE(poly[36], QPoint(102,102));
+    QCOMPARE(poly[37], QPoint(96,96));
+    QCOMPARE(poly[38], QPoint(90,90));
+    QCOMPARE(poly[39], QPoint(84,84));
+    QCOMPARE(poly[40], QPoint(78,78));
+    QCOMPARE(poly[41], QPoint(72,72));
+    QCOMPARE(poly[42], QPoint(67,67));
+    QCOMPARE(poly[43], QPoint(61,61));
+    QCOMPARE(poly[44], QPoint(56,56));
+    QCOMPARE(poly[45], QPoint(51,51));
+    QCOMPARE(poly[46], QPoint(46,46));
+    QCOMPARE(poly[47], QPoint(41,41));
+    QCOMPARE(poly[48], QPoint(37,37));
+    QCOMPARE(poly[49], QPoint(32,32));
+    QCOMPARE(poly[50], QPoint(28,28));
+    QCOMPARE(poly[51], QPoint(24,24));
+    QCOMPARE(poly[52], QPoint(21,21));
+    QCOMPARE(poly[53], QPoint(18,18));
+    QCOMPARE(poly[54], QPoint(14,14));
+    QCOMPARE(poly[55], QPoint(12,12));
+    QCOMPARE(poly[56], QPoint(9,9));
+    QCOMPARE(poly[57], QPoint(7,7));
+    QCOMPARE(poly[58], QPoint(5,5));
+    QCOMPARE(poly[59], QPoint(3,3));
+    QCOMPARE(poly[60], QPoint(2,2));
+    QCOMPARE(poly[61], QPoint(1,1));
+    QCOMPARE(poly[62], QPoint(0,0));
+    QCOMPARE(poly[63], QPoint(0,0));
+    QCOMPARE(poly[64], QPoint(0,0));
+    QCOMPARE(poly[65], QPoint(0,0));
+    QCOMPARE(poly[66], QPoint(0,0));
+    QCOMPARE(poly[67], QPoint(1,1));
+    QCOMPARE(poly[68], QPoint(2,2));
+    QCOMPARE(poly[69], QPoint(3,3));
+    QCOMPARE(poly[70], QPoint(5,5));
+    QCOMPARE(poly[71], QPoint(7,7));
+    QCOMPARE(poly[72], QPoint(9,9));
+    QCOMPARE(poly[73], QPoint(12,12));
+    QCOMPARE(poly[74], QPoint(14,14));
+    QCOMPARE(poly[75], QPoint(18,18));
+    QCOMPARE(poly[76], QPoint(21,21));
+    QCOMPARE(poly[77], QPoint(24,24));
+    QCOMPARE(poly[78], QPoint(28,28));
+    QCOMPARE(poly[79], QPoint(32,32));
+    QCOMPARE(poly[80], QPoint(37,37));
+    QCOMPARE(poly[81], QPoint(41,41));
+    QCOMPARE(poly[82], QPoint(46,46));
+    QCOMPARE(poly[83], QPoint(51,51));
+    QCOMPARE(poly[84], QPoint(56,56));
+    QCOMPARE(poly[85], QPoint(61,61));
+    QCOMPARE(poly[86], QPoint(67,67));
+    QCOMPARE(poly[87], QPoint(72,72));
+    QCOMPARE(poly[88], QPoint(78,78));
+    QCOMPARE(poly[89], QPoint(84,84));
+    QCOMPARE(poly[90], QPoint(90,90));
+    QCOMPARE(poly[91], QPoint(96,96));
+    QCOMPARE(poly[92], QPoint(102,102));
+    QCOMPARE(poly[93], QPoint(108,108));
+    QCOMPARE(poly[94], QPoint(114,114));
+    QCOMPARE(poly[95], QPoint(120,120));
+    QCOMPARE(poly[96], QPoint(126,126));
+    QCOMPARE(poly[97], QPoint(133,133));
+    QCOMPARE(poly[98], QPoint(139,139));
+    QCOMPARE(poly[99], QPoint(145,145));
+    QCOMPARE(poly[100], QPoint(151,151));
+    QCOMPARE(poly[101], QPoint(157,157));
+    QCOMPARE(poly[102], QPoint(163,163));
+    QCOMPARE(poly[103], QPoint(169,169));
+    QCOMPARE(poly[104], QPoint(175,175));
+    QCOMPARE(poly[105], QPoint(181,181));
+    QCOMPARE(poly[106], QPoint(186,186));
+    QCOMPARE(poly[107], QPoint(192,192));
+    QCOMPARE(poly[108], QPoint(197,197));
+    QCOMPARE(poly[109], QPoint(202,202));
+    QCOMPARE(poly[110], QPoint(207,207));
+    QCOMPARE(poly[111], QPoint(212,212));
+    QCOMPARE(poly[112], QPoint(216,216));
+    QCOMPARE(poly[113], QPoint(221,221));
+    QCOMPARE(poly[114], QPoint(225,225));
+    QCOMPARE(poly[115], QPoint(229,229));
+    QCOMPARE(poly[116], QPoint(232,232));
+    QCOMPARE(poly[117], QPoint(235,235));
+    QCOMPARE(poly[118], QPoint(239,239));
+    QCOMPARE(poly[119], QPoint(241,241));
+    QCOMPARE(poly[120], QPoint(244,244));
+    QCOMPARE(poly[121], QPoint(246,246));
+    QCOMPARE(poly[122], QPoint(248,248));
+    QCOMPARE(poly[123], QPoint(250,250));
+    QCOMPARE(poly[124], QPoint(251,251));
+    QCOMPARE(poly[125], QPoint(252,252));
+    QCOMPARE(poly[126], QPoint(253,253));
+    QCOMPARE(poly[127], QPoint(253,253));
 }

 void EFX_Test::previewDiamond()
@@ -969,137 +969,137 @@
     e.setAlgorithm(EFX::Diamond);

     QVector <QPoint> poly;
-    QVERIFY(e.preview(Function::Forward, poly) == true);
-    QVERIFY(poly.size() == 128);
-
-    QVERIFY(poly[0] == QPoint(127,254));
-    QVERIFY(poly[1] == QPoint(127,253));
-    QVERIFY(poly[2] == QPoint(127,252));
-    QVERIFY(poly[3] == QPoint(127,249));
-    QVERIFY(poly[4] == QPoint(127,246));
-    QVERIFY(poly[5] == QPoint(128,242));
-    QVERIFY(poly[6] == QPoint(130,238));
-    QVERIFY(poly[7] == QPoint(131,233));
-    QVERIFY(poly[8] == QPoint(134,227));
-    QVERIFY(poly[9] == QPoint(136,220));
-    QVERIFY(poly[10] == QPoint(140,214));
-    QVERIFY(poly[11] == QPoint(144,207));
-    QVERIFY(poly[12] == QPoint(148,200));
-    QVERIFY(poly[13] == QPoint(153,192));
-    QVERIFY(poly[14] == QPoint(159,185));
-    QVERIFY(poly[15] == QPoint(165,178));
-    QVERIFY(poly[16] == QPoint(171,171));
-    QVERIFY(poly[17] == QPoint(178,165));
-    QVERIFY(poly[18] == QPoint(185,159));
-    QVERIFY(poly[19] == QPoint(192,153));
-    QVERIFY(poly[20] == QPoint(200,148));
-    QVERIFY(poly[21] == QPoint(207,144));
-    QVERIFY(poly[22] == QPoint(214,140));
-    QVERIFY(poly[23] == QPoint(220,136));
-    QVERIFY(poly[24] == QPoint(227,134));
-    QVERIFY(poly[25] == QPoint(233,131));
-    QVERIFY(poly[26] == QPoint(238,130));
-    QVERIFY(poly[27] == QPoint(242,128));
-    QVERIFY(poly[28] == QPoint(246,127));
-    QVERIFY(poly[29] == QPoint(249,127));
-    QVERIFY(poly[30] == QPoint(252,127));
-    QVERIFY(poly[31] == QPoint(253,127));
-    QVERIFY(poly[32] == QPoint(254,127));
-    QVERIFY(poly[33] == QPoint(253,126));
-    QVERIFY(poly[34] == QPoint(252,126));
-    QVERIFY(poly[35] == QPoint(249,126));
-    QVERIFY(poly[36] == QPoint(246,126));
-    QVERIFY(poly[37] == QPoint(242,125));
-    QVERIFY(poly[38] == QPoint(238,123));
-    QVERIFY(poly[39] == QPoint(233,122));
-    QVERIFY(poly[40] == QPoint(227,119));
-    QVERIFY(poly[41] == QPoint(220,117));
-    QVERIFY(poly[42] == QPoint(214,113));
-    QVERIFY(poly[43] == QPoint(207,109));
-    QVERIFY(poly[44] == QPoint(200,105));
-    QVERIFY(poly[45] == QPoint(192,100));
-    QVERIFY(poly[46] == QPoint(185,94));
-    QVERIFY(poly[47] == QPoint(178,88));
-    QVERIFY(poly[48] == QPoint(171,82));
-    QVERIFY(poly[49] == QPoint(165,75));
-    QVERIFY(poly[50] == QPoint(159,68));
-    QVERIFY(poly[51] == QPoint(153,61));
-    QVERIFY(poly[52] == QPoint(148,53));
-    QVERIFY(poly[53] == QPoint(144,46));
-    QVERIFY(poly[54] == QPoint(140,39));
-    QVERIFY(poly[55] == QPoint(136,33));
-    QVERIFY(poly[56] == QPoint(134,26));
-    QVERIFY(poly[57] == QPoint(131,20));
-    QVERIFY(poly[58] == QPoint(130,15));
-    QVERIFY(poly[59] == QPoint(128,11));
-    QVERIFY(poly[60] == QPoint(127,7));
-    QVERIFY(poly[61] == QPoint(127,4));
-    QVERIFY(poly[62] == QPoint(127,1));
-    QVERIFY(poly[63] == QPoint(127,0));
-    QVERIFY(poly[64] == QPoint(127,0));
-    QVERIFY(poly[65] == QPoint(126,0));
-    QVERIFY(poly[66] == QPoint(126,1));
-    QVERIFY(poly[67] == QPoint(126,4));
-    QVERIFY(poly[68] == QPoint(126,7));
-    QVERIFY(poly[69] == QPoint(125,11));
-    QVERIFY(poly[70] == QPoint(123,15));
-    QVERIFY(poly[71] == QPoint(122,20));
-    QVERIFY(poly[72] == QPoint(119,26));
-    QVERIFY(poly[73] == QPoint(117,33));
-    QVERIFY(poly[74] == QPoint(113,39));
-    QVERIFY(poly[75] == QPoint(109,46));
-    QVERIFY(poly[76] == QPoint(105,53));
-    QVERIFY(poly[77] == QPoint(100,61));
-    QVERIFY(poly[78] == QPoint(94,68));
-    QVERIFY(poly[79] == QPoint(88,75));
-    QVERIFY(poly[80] == QPoint(82,82));
-    QVERIFY(poly[81] == QPoint(75,88));
-    QVERIFY(poly[82] == QPoint(68,94));
-    QVERIFY(poly[83] == QPoint(61,100));
-    QVERIFY(poly[84] == QPoint(53,105));
-    QVERIFY(poly[85] == QPoint(46,109));
-    QVERIFY(poly[86] == QPoint(39,113));
-    QVERIFY(poly[87] == QPoint(33,117));
-    QVERIFY(poly[88] == QPoint(26,119));
-    QVERIFY(poly[89] == QPoint(20,122));
-    QVERIFY(poly[90] == QPoint(15,123));
-    QVERIFY(poly[91] == QPoint(11,125));
-    QVERIFY(poly[92] == QPoint(7,126));
-    QVERIFY(poly[93] == QPoint(4,126));
-    QVERIFY(poly[94] == QPoint(1,126));
-    QVERIFY(poly[95] == QPoint(0,126));
-    QVERIFY(poly[96] == QPoint(0,127));
-    QVERIFY(poly[97] == QPoint(0,127));
-    QVERIFY(poly[98] == QPoint(1,127));
-    QVERIFY(poly[99] == QPoint(4,127));
-    QVERIFY(poly[100] == QPoint(7,127));
-    QVERIFY(poly[101] == QPoint(11,128));
-    QVERIFY(poly[102] == QPoint(15,130));
-    QVERIFY(poly[103] == QPoint(20,131));
-    QVERIFY(poly[104] == QPoint(26,134));
-    QVERIFY(poly[105] == QPoint(33,136));
-    QVERIFY(poly[106] == QPoint(39,140));
-    QVERIFY(poly[107] == QPoint(46,144));
-    QVERIFY(poly[108] == QPoint(53,148));
-    QVERIFY(poly[109] == QPoint(61,153));
-    QVERIFY(poly[110] == QPoint(68,159));
-    QVERIFY(poly[111] == QPoint(75,165));
-    QVERIFY(poly[112] == QPoint(82,171));
-    QVERIFY(poly[113] == QPoint(88,178));
-    QVERIFY(poly[114] == QPoint(94,185));
-    QVERIFY(poly[115] == QPoint(100,192));
-    QVERIFY(poly[116] == QPoint(105,200));
-    QVERIFY(poly[117] == QPoint(109,207));
-    QVERIFY(poly[118] == QPoint(113,214));
-    QVERIFY(poly[119] == QPoint(117,220));
-    QVERIFY(poly[120] == QPoint(119,227));
-    QVERIFY(poly[121] == QPoint(122,233));
-    QVERIFY(poly[122] == QPoint(123,238));
-    QVERIFY(poly[123] == QPoint(125,242));
-    QVERIFY(poly[124] == QPoint(126,246));
-    QVERIFY(poly[125] == QPoint(126,249));
-    QVERIFY(poly[126] == QPoint(126,252));
-    QVERIFY(poly[127] == QPoint(126,253));
+    QVERIFY(e.preview(Function::Forward, poly));
+    QCOMPARE(poly.size(), 128);
+
+    QCOMPARE(poly[0], QPoint(127,254));
+    QCOMPARE(poly[1], QPoint(127,253));
+    QCOMPARE(poly[2], QPoint(127,252));
+    QCOMPARE(poly[3], QPoint(127,249));
+    QCOMPARE(poly[4], QPoint(127,246));
+    QCOMPARE(poly[5], QPoint(128,242));
+    QCOMPARE(poly[6], QPoint(130,238));
+    QCOMPARE(poly[7], QPoint(131,233));
+    QCOMPARE(poly[8], QPoint(134,227));
+    QCOMPARE(poly[9], QPoint(136,220));
+    QCOMPARE(poly[10], QPoint(140,214));
+    QCOMPARE(poly[11], QPoint(144,207));
+    QCOMPARE(poly[12], QPoint(148,200));
+    QCOMPARE(poly[13], QPoint(153,192));
+    QCOMPARE(poly[14], QPoint(159,185));
+    QCOMPARE(poly[15], QPoint(165,178));
+    QCOMPARE(poly[16], QPoint(171,171));
+    QCOMPARE(poly[17], QPoint(178,165));
+    QCOMPARE(poly[18], QPoint(185,159));
+    QCOMPARE(poly[19], QPoint(192,153));
+    QCOMPARE(poly[20], QPoint(200,148));
+    QCOMPARE(poly[21], QPoint(207,144));
+    QCOMPARE(poly[22], QPoint(214,140));
+    QCOMPARE(poly[23], QPoint(220,136));
+    QCOMPARE(poly[24], QPoint(227,134));
+    QCOMPARE(poly[25], QPoint(233,131));
+    QCOMPARE(poly[26], QPoint(238,130));
+    QCOMPARE(poly[27], QPoint(242,128));
+    QCOMPARE(poly[28], QPoint(246,127));
+    QCOMPARE(poly[29], QPoint(249,127));
+    QCOMPARE(poly[30], QPoint(252,127));
+    QCOMPARE(poly[31], QPoint(253,127));
+    QCOMPARE(poly[32], QPoint(254,127));
+    QCOMPARE(poly[33], QPoint(253,126));
+    QCOMPARE(poly[34], QPoint(252,126));
+    QCOMPARE(poly[35], QPoint(249,126));
+    QCOMPARE(poly[36], QPoint(246,126));
+    QCOMPARE(poly[37], QPoint(242,125));
+    QCOMPARE(poly[38], QPoint(238,123));
+    QCOMPARE(poly[39], QPoint(233,122));
+    QCOMPARE(poly[40], QPoint(227,119));
+    QCOMPARE(poly[41], QPoint(220,117));
+    QCOMPARE(poly[42], QPoint(214,113));
+    QCOMPARE(poly[43], QPoint(207,109));
+    QCOMPARE(poly[44], QPoint(200,105));
+    QCOMPARE(poly[45], QPoint(192,100));
+    QCOMPARE(poly[46], QPoint(185,94));
+    QCOMPARE(poly[47], QPoint(178,88));
+    QCOMPARE(poly[48], QPoint(171,82));
+    QCOMPARE(poly[49], QPoint(165,75));
+    QCOMPARE(poly[50], QPoint(159,68));
+    QCOMPARE(poly[51], QPoint(153,61));
+    QCOMPARE(poly[52], QPoint(148,53));
+    QCOMPARE(poly[53], QPoint(144,46));
+    QCOMPARE(poly[54], QPoint(140,39));
+    QCOMPARE(poly[55], QPoint(136,33));
+    QCOMPARE(poly[56], QPoint(134,26));
+    QCOMPARE(poly[57], QPoint(131,20));
+    QCOMPARE(poly[58], QPoint(130,15));
+    QCOMPARE(poly[59], QPoint(128,11));
+    QCOMPARE(poly[60], QPoint(127,7));
+    QCOMPARE(poly[61], QPoint(127,4));
+    QCOMPARE(poly[62], QPoint(127,1));
+    QCOMPARE(poly[63], QPoint(127,0));
+    QCOMPARE(poly[64], QPoint(127,0));
+    QCOMPARE(poly[65], QPoint(126,0));
+    QCOMPARE(poly[66], QPoint(126,1));
+    QCOMPARE(poly[67], QPoint(126,4));
+    QCOMPARE(poly[68], QPoint(126,7));
+    QCOMPARE(poly[69], QPoint(125,11));
+    QCOMPARE(poly[70], QPoint(123,15));
+    QCOMPARE(poly[71], QPoint(122,20));
+    QCOMPARE(poly[72], QPoint(119,26));
+    QCOMPARE(poly[73], QPoint(117,33));
+    QCOMPARE(poly[74], QPoint(113,39));
+    QCOMPARE(poly[75], QPoint(109,46));
+    QCOMPARE(poly[76], QPoint(105,53));
+    QCOMPARE(poly[77], QPoint(100,61));
+    QCOMPARE(poly[78], QPoint(94,68));
+    QCOMPARE(poly[79], QPoint(88,75));
+    QCOMPARE(poly[80], QPoint(82,82));
+    QCOMPARE(poly[81], QPoint(75,88));
+    QCOMPARE(poly[82], QPoint(68,94));
+    QCOMPARE(poly[83], QPoint(61,100));
+    QCOMPARE(poly[84], QPoint(53,105));
+    QCOMPARE(poly[85], QPoint(46,109));
+    QCOMPARE(poly[86], QPoint(39,113));
+    QCOMPARE(poly[87], QPoint(33,117));
+    QCOMPARE(poly[88], QPoint(26,119));
+    QCOMPARE(poly[89], QPoint(20,122));
+    QCOMPARE(poly[90], QPoint(15,123));
+    QCOMPARE(poly[91], QPoint(11,125));
+    QCOMPARE(poly[92], QPoint(7,126));
+    QCOMPARE(poly[93], QPoint(4,126));
+    QCOMPARE(poly[94], QPoint(1,126));
+    QCOMPARE(poly[95], QPoint(0,126));
+    QCOMPARE(poly[96], QPoint(0,127));
+    QCOMPARE(poly[97], QPoint(0,127));
+    QCOMPARE(poly[98], QPoint(1,127));
+    QCOMPARE(poly[99], QPoint(4,127));
+    QCOMPARE(poly[100], QPoint(7,127));
+    QCOMPARE(poly[101], QPoint(11,128));
+    QCOMPARE(poly[102], QPoint(15,130));
+    QCOMPARE(poly[103], QPoint(20,131));
+    QCOMPARE(poly[104], QPoint(26,134));
+    QCOMPARE(poly[105], QPoint(33,136));
+    QCOMPARE(poly[106], QPoint(39,140));
+    QCOMPARE(poly[107], QPoint(46,144));
+    QCOMPARE(poly[108], QPoint(53,148));
+    QCOMPARE(poly[109], QPoint(61,153));
+    QCOMPARE(poly[110], QPoint(68,159));
+    QCOMPARE(poly[111], QPoint(75,165));
+    QCOMPARE(poly[112], QPoint(82,171));
+    QCOMPARE(poly[113], QPoint(88,178));
+    QCOMPARE(poly[114], QPoint(94,185));
+    QCOMPARE(poly[115], QPoint(100,192));
+    QCOMPARE(poly[116], QPoint(105,200));
+    QCOMPARE(poly[117], QPoint(109,207));
+    QCOMPARE(poly[118], QPoint(113,214));
+    QCOMPARE(poly[119], QPoint(117,220));
+    QCOMPARE(poly[120], QPoint(119,227));
+    QCOMPARE(poly[121], QPoint(122,233));
+    QCOMPARE(poly[122], QPoint(123,238));
+    QCOMPARE(poly[123], QPoint(125,242));
+    QCOMPARE(poly[124], QPoint(126,246));
+    QCOMPARE(poly[125], QPoint(126,249));
+    QCOMPARE(poly[126], QPoint(126,252));
+    QCOMPARE(poly[127], QPoint(126,253));
 }

 void EFX_Test::previewLissajous()
@@ -1108,137 +1108,137 @@
     e.setAlgorithm(EFX::Lissajous);

     QVector <QPoint> poly;
-    QVERIFY(e.preview(Function::Forward, poly) == true);
-    QVERIFY(poly.size() == 128);
-
-    QVERIFY(poly[0] == QPoint(127,254));
-    QVERIFY(poly[1] == QPoint(139,252));
-    QVERIFY(poly[2] == QPoint(151,248));
-    QVERIFY(poly[3] == QPoint(163,241));
-    QVERIFY(poly[4] == QPoint(175,232));
-    QVERIFY(poly[5] == QPoint(186,221));
-    QVERIFY(poly[6] == QPoint(197,207));
-    QVERIFY(poly[7] == QPoint(207,192));
-    QVERIFY(poly[8] == QPoint(216,175));
-    QVERIFY(poly[9] == QPoint(225,157));
-    QVERIFY(poly[10] == QPoint(232,139));
-    QVERIFY(poly[11] == QPoint(239,120));
-    QVERIFY(poly[12] == QPoint(244,102));
-    QVERIFY(poly[13] == QPoint(248,84));
-    QVERIFY(poly[14] == QPoint(251,67));
-    QVERIFY(poly[15] == QPoint(253,51));
-    QVERIFY(poly[16] == QPoint(254,37));
-    QVERIFY(poly[17] == QPoint(253,24));
-    QVERIFY(poly[18] == QPoint(251,14));
-    QVERIFY(poly[19] == QPoint(248,7));
-    QVERIFY(poly[20] == QPoint(244,2));
-    QVERIFY(poly[21] == QPoint(239,0));
-    QVERIFY(poly[22] == QPoint(232,0));
-    QVERIFY(poly[23] == QPoint(225,3));
-    QVERIFY(poly[24] == QPoint(216,9));
-    QVERIFY(poly[25] == QPoint(207,18));
-    QVERIFY(poly[26] == QPoint(197,28));
-    QVERIFY(poly[27] == QPoint(186,41));
-    QVERIFY(poly[28] == QPoint(175,56));
-    QVERIFY(poly[29] == QPoint(163,72));
-    QVERIFY(poly[30] == QPoint(151,90));
-    QVERIFY(poly[31] == QPoint(139,108));
-    QVERIFY(poly[32] == QPoint(126,127));
-    QVERIFY(poly[33] == QPoint(114,145));
-    QVERIFY(poly[34] == QPoint(102,163));
-    QVERIFY(poly[35] == QPoint(90,181));
-    QVERIFY(poly[36] == QPoint(78,197));
-    QVERIFY(poly[37] == QPoint(67,212));
-    QVERIFY(poly[38] == QPoint(56,225));
-    QVERIFY(poly[39] == QPoint(46,235));
-    QVERIFY(poly[40] == QPoint(37,244));
-    QVERIFY(poly[41] == QPoint(28,250));
-    QVERIFY(poly[42] == QPoint(21,253));
-    QVERIFY(poly[43] == QPoint(14,253));
-    QVERIFY(poly[44] == QPoint(9,251));
-    QVERIFY(poly[45] == QPoint(5,246));
-    QVERIFY(poly[46] == QPoint(2,239));
-    QVERIFY(poly[47] == QPoint(0,229));
-    QVERIFY(poly[48] == QPoint(0,216));
-    QVERIFY(poly[49] == QPoint(0,202));
-    QVERIFY(poly[50] == QPoint(2,186));
-    QVERIFY(poly[51] == QPoint(5,169));
-    QVERIFY(poly[52] == QPoint(9,151));
-    QVERIFY(poly[53] == QPoint(14,133));
-    QVERIFY(poly[54] == QPoint(21,114));
-    QVERIFY(poly[55] == QPoint(28,96));
-    QVERIFY(poly[56] == QPoint(37,78));
-    QVERIFY(poly[57] == QPoint(46,61));
-    QVERIFY(poly[58] == QPoint(56,46));
-    QVERIFY(poly[59] == QPoint(67,32));
-    QVERIFY(poly[60] == QPoint(78,21));
-    QVERIFY(poly[61] == QPoint(90,12));
-    QVERIFY(poly[62] == QPoint(102,5));
-    QVERIFY(poly[63] == QPoint(114,1));
-    QVERIFY(poly[64] == QPoint(126,0));
-    QVERIFY(poly[65] == QPoint(139,1));
-    QVERIFY(poly[66] == QPoint(151,5));
-    QVERIFY(poly[67] == QPoint(163,12));
-    QVERIFY(poly[68] == QPoint(175,21));
-    QVERIFY(poly[69] == QPoint(186,32));
-    QVERIFY(poly[70] == QPoint(197,46));
-    QVERIFY(poly[71] == QPoint(207,61));
-    QVERIFY(poly[72] == QPoint(216,78));
-    QVERIFY(poly[73] == QPoint(225,96));
-    QVERIFY(poly[74] == QPoint(232,114));
-    QVERIFY(poly[75] == QPoint(239,133));
-    QVERIFY(poly[76] == QPoint(244,151));
-    QVERIFY(poly[77] == QPoint(248,169));
-    QVERIFY(poly[78] == QPoint(251,186));
-    QVERIFY(poly[79] == QPoint(253,202));
-    QVERIFY(poly[80] == QPoint(254,216));
-    QVERIFY(poly[81] == QPoint(253,229));
-    QVERIFY(poly[82] == QPoint(251,239));
-    QVERIFY(poly[83] == QPoint(248,246));
-    QVERIFY(poly[84] == QPoint(244,251));
-    QVERIFY(poly[85] == QPoint(239,253));
-    QVERIFY(poly[86] == QPoint(232,253));
-    QVERIFY(poly[87] == QPoint(225,250));
-    QVERIFY(poly[88] == QPoint(216,244));
-    QVERIFY(poly[89] == QPoint(207,235));
-    QVERIFY(poly[90] == QPoint(197,225));
-    QVERIFY(poly[91] == QPoint(186,212));
-    QVERIFY(poly[92] == QPoint(175,197));
-    QVERIFY(poly[93] == QPoint(163,181));
-    QVERIFY(poly[94] == QPoint(151,163));
-    QVERIFY(poly[95] == QPoint(139,145));
-    QVERIFY(poly[96] == QPoint(127,127));
-    QVERIFY(poly[97] == QPoint(114,108));
-    QVERIFY(poly[98] == QPoint(102,90));
-    QVERIFY(poly[99] == QPoint(90,72));
-    QVERIFY(poly[100] == QPoint(78,56));
-    QVERIFY(poly[101] == QPoint(67,41));
-    QVERIFY(poly[102] == QPoint(56,28));
-    QVERIFY(poly[103] == QPoint(46,18));
-    QVERIFY(poly[104] == QPoint(37,9));
-    QVERIFY(poly[105] == QPoint(28,3));
-    QVERIFY(poly[106] == QPoint(21,0));
-    QVERIFY(poly[107] == QPoint(14,0));
-    QVERIFY(poly[108] == QPoint(9,2));
-    QVERIFY(poly[109] == QPoint(5,7));
-    QVERIFY(poly[110] == QPoint(2,14));
-    QVERIFY(poly[111] == QPoint(0,24));
-    QVERIFY(poly[112] == QPoint(0,37));
-    QVERIFY(poly[113] == QPoint(0,51));
-    QVERIFY(poly[114] == QPoint(2,67));
-    QVERIFY(poly[115] == QPoint(5,84));
-    QVERIFY(poly[116] == QPoint(9,102));
-    QVERIFY(poly[117] == QPoint(14,120));
-    QVERIFY(poly[118] == QPoint(21,139));
-    QVERIFY(poly[119] == QPoint(28,157));
-    QVERIFY(poly[120] == QPoint(37,175));
-    QVERIFY(poly[121] == QPoint(46,192));
-    QVERIFY(poly[122] == QPoint(56,207));
-    QVERIFY(poly[123] == QPoint(67,221));
-    QVERIFY(poly[124] == QPoint(78,232));
-    QVERIFY(poly[125] == QPoint(90,241));
-    QVERIFY(poly[126] == QPoint(102,248));
-    QVERIFY(poly[127] == QPoint(114,252));
+    QVERIFY(e.preview(Function::Forward, poly));
+    QCOMPARE(poly.size(), 128);
+
+    QCOMPARE(poly[0], QPoint(127,254));
+    QCOMPARE(poly[1], QPoint(139,252));
+    QCOMPARE(poly[2], QPoint(151,248));
+    QCOMPARE(poly[3], QPoint(163,241));
+    QCOMPARE(poly[4], QPoint(175,232));
+    QCOMPARE(poly[5], QPoint(186,221));
+    QCOMPARE(poly[6], QPoint(197,207));
+    QCOMPARE(poly[7], QPoint(207,192));
+    QCOMPARE(poly[8], QPoint(216,175));
+    QCOMPARE(poly[9], QPoint(225,157));
+    QCOMPARE(poly[10], QPoint(232,139));
+    QCOMPARE(poly[11], QPoint(239,120));
+    QCOMPARE(poly[12], QPoint(244,102));
+    QCOMPARE(poly[13], QPoint(248,84));
+    QCOMPARE(poly[14], QPoint(251,67));
+    QCOMPARE(poly[15], QPoint(253,51));
+    QCOMPARE(poly[16], QPoint(254,37));
+    QCOMPARE(poly[17], QPoint(253,24));
+    QCOMPARE(poly[18], QPoint(251,14));
+    QCOMPARE(poly[19], QPoint(248,7));
+    QCOMPARE(poly[20], QPoint(244,2));
+    QCOMPARE(poly[21], QPoint(239,0));
+    QCOMPARE(poly[22], QPoint(232,0));
+    QCOMPARE(poly[23], QPoint(225,3));
+    QCOMPARE(poly[24], QPoint(216,9));
+    QCOMPARE(poly[25], QPoint(207,18));
+    QCOMPARE(poly[26], QPoint(197,28));
+    QCOMPARE(poly[27], QPoint(186,41));
+    QCOMPARE(poly[28], QPoint(175,56));
+    QCOMPARE(poly[29], QPoint(163,72));
+    QCOMPARE(poly[30], QPoint(151,90));
+    QCOMPARE(poly[31], QPoint(139,108));
+    QCOMPARE(poly[32], QPoint(126,127));
+    QCOMPARE(poly[33], QPoint(114,145));
+    QCOMPARE(poly[34], QPoint(102,163));
+    QCOMPARE(poly[35], QPoint(90,181));
+    QCOMPARE(poly[36], QPoint(78,197));
+    QCOMPARE(poly[37], QPoint(67,212));
+    QCOMPARE(poly[38], QPoint(56,225));
+    QCOMPARE(poly[39], QPoint(46,235));
+    QCOMPARE(poly[40], QPoint(37,244));
+    QCOMPARE(poly[41], QPoint(28,250));
+    QCOMPARE(poly[42], QPoint(21,253));
+    QCOMPARE(poly[43], QPoint(14,253));
+    QCOMPARE(poly[44], QPoint(9,251));
+    QCOMPARE(poly[45], QPoint(5,246));
+    QCOMPARE(poly[46], QPoint(2,239));
+    QCOMPARE(poly[47], QPoint(0,229));
+    QCOMPARE(poly[48], QPoint(0,216));
+    QCOMPARE(poly[49], QPoint(0,202));
+    QCOMPARE(poly[50], QPoint(2,186));
+    QCOMPARE(poly[51], QPoint(5,169));
+    QCOMPARE(poly[52], QPoint(9,151));
+    QCOMPARE(poly[53], QPoint(14,133));
+    QCOMPARE(poly[54], QPoint(21,114));
+    QCOMPARE(poly[55], QPoint(28,96));
+    QCOMPARE(poly[56], QPoint(37,78));
+    QCOMPARE(poly[57], QPoint(46,61));
+    QCOMPARE(poly[58], QPoint(56,46));
+    QCOMPARE(poly[59], QPoint(67,32));
+    QCOMPARE(poly[60], QPoint(78,21));
+    QCOMPARE(poly[61], QPoint(90,12));
+    QCOMPARE(poly[62], QPoint(102,5));
+    QCOMPARE(poly[63], QPoint(114,1));
+    QCOMPARE(poly[64], QPoint(126,0));
+    QCOMPARE(poly[65], QPoint(139,1));
+    QCOMPARE(poly[66], QPoint(151,5));
+    QCOMPARE(poly[67], QPoint(163,12));
+    QCOMPARE(poly[68], QPoint(175,21));
+    QCOMPARE(poly[69], QPoint(186,32));
+    QCOMPARE(poly[70], QPoint(197,46));
+    QCOMPARE(poly[71], QPoint(207,61));
+    QCOMPARE(poly[72], QPoint(216,78));
+    QCOMPARE(poly[73], QPoint(225,96));
+    QCOMPARE(poly[74], QPoint(232,114));
+    QCOMPARE(poly[75], QPoint(239,133));
+    QCOMPARE(poly[76], QPoint(244,151));
+    QCOMPARE(poly[77], QPoint(248,169));
+    QCOMPARE(poly[78], QPoint(251,186));
+    QCOMPARE(poly[79], QPoint(253,202));
+    QCOMPARE(poly[80], QPoint(254,216));
+    QCOMPARE(poly[81], QPoint(253,229));
+    QCOMPARE(poly[82], QPoint(251,239));
+    QCOMPARE(poly[83], QPoint(248,246));
+    QCOMPARE(poly[84], QPoint(244,251));
+    QCOMPARE(poly[85], QPoint(239,253));
+    QCOMPARE(poly[86], QPoint(232,253));
+    QCOMPARE(poly[87], QPoint(225,250));
+    QCOMPARE(poly[88], QPoint(216,244));
+    QCOMPARE(poly[89], QPoint(207,235));
+    QCOMPARE(poly[90], QPoint(197,225));
+    QCOMPARE(poly[91], QPoint(186,212));
+    QCOMPARE(poly[92], QPoint(175,197));
+    QCOMPARE(poly[93], QPoint(163,181));
+    QCOMPARE(poly[94], QPoint(151,163));
+    QCOMPARE(poly[95], QPoint(139,145));
+    QCOMPARE(poly[96], QPoint(127,127));
+    QCOMPARE(poly[97], QPoint(114,108));
+    QCOMPARE(poly[98], QPoint(102,90));
+    QCOMPARE(poly[99], QPoint(90,72));
+    QCOMPARE(poly[100], QPoint(78,56));
+    QCOMPARE(poly[101], QPoint(67,41));
+    QCOMPARE(poly[102], QPoint(56,28));
+    QCOMPARE(poly[103], QPoint(46,18));
+    QCOMPARE(poly[104], QPoint(37,9));
+    QCOMPARE(poly[105], QPoint(28,3));
+    QCOMPARE(poly[106], QPoint(21,0));
+    QCOMPARE(poly[107], QPoint(14,0));
+    QCOMPARE(poly[108], QPoint(9,2));
+    QCOMPARE(poly[109], QPoint(5,7));
+    QCOMPARE(poly[110], QPoint(2,14));
+    QCOMPARE(poly[111], QPoint(0,24));
+    QCOMPARE(poly[112], QPoint(0,37));
+    QCOMPARE(poly[113], QPoint(0,51));
+    QCOMPARE(poly[114], QPoint(2,67));
+    QCOMPARE(poly[115], QPoint(5,84));
+    QCOMPARE(poly[116], QPoint(9,102));
+    QCOMPARE(poly[117], QPoint(14,120));
+    QCOMPARE(poly[118], QPoint(21,139));
+    QCOMPARE(poly[119], QPoint(28,157));
+    QCOMPARE(poly[120], QPoint(37,175));
+    QCOMPARE(poly[121], QPoint(46,192));
+    QCOMPARE(poly[122], QPoint(56,207));
+    QCOMPARE(poly[123], QPoint(67,221));
+    QCOMPARE(poly[124], QPoint(78,232));
+    QCOMPARE(poly[125], QPoint(90,241));
+    QCOMPARE(poly[126], QPoint(102,248));
+    QCOMPARE(poly[127], QPoint(114,252));
 }

 void EFX_Test::widthHeightOffset()
@@ -1248,13 +1248,13 @@
     int max = 0;

     QVector <QPoint> poly;
-    QVERIFY(e.preview(Function::Forward, poly) == true);
-    QVERIFY(poly.size() == 128);
+    QVERIFY(e.preview(Function::Forward, poly));
+    QCOMPARE(poly.size(), 128);

     /* Check that width affects the pattern */
     e.setWidth(50);
     poly.clear();
-    QVERIFY(e.preview(Function::Forward, poly) == true);
+    QVERIFY(e.preview(Function::Forward, poly));
     QVERIFY(poly.size() == 128);

     /* Width of 50 means actually 50px left of center (127-50) and
@@ -1266,7 +1266,7 @@
     /* Check that height affects the pattern */
     e.setHeight(87);
     poly.clear();
-    QVERIFY(e.preview(Function::Forward, poly) == true);
+    QVERIFY(e.preview(Function::Forward, poly));
     QVERIFY(poly.size() == 128);

     /* Height of 87 means actually 87px down of center (127-87) and
@@ -1278,7 +1278,7 @@
     /* X Offset is at center */
     max = 0;
     poly.clear();
-    QVERIFY(e.preview(Function::Forward, poly) == true);
+    QVERIFY(e.preview(Function::Forward, poly));
     QVERIFY(poly.size() == 128);
     for (i = 0; i < 128; i++)
         if (poly[i].x() > max)
@@ -1289,7 +1289,7 @@
     max = 0;
     e.setXOffset(127 + 20);
     poly.clear();
-    QVERIFY(e.preview(Function::Forward, poly) == true);
+    QVERIFY(e.preview(Function::Forward, poly));
     QVERIFY(poly.size() == 128);
     for (i = 0; i < 128; i++)
         if (poly[i].x() > max)
@@ -1299,7 +1299,7 @@
     /* Y Offset is at center */
     max = 0;
     poly.clear();
-    QVERIFY(e.preview(Function::Forward, poly) == true);
+    QVERIFY(e.preview(Function::Forward, poly));
     QVERIFY(poly.size() == 128);
     for (i = 0; i < 128; i++)
         if (poly[i].y() > max)
@@ -1310,7 +1310,7 @@
     max = 0;
     e.setYOffset(127 - 25);
     poly.clear();
-    QVERIFY(e.preview(Function::Forward, poly) == true);
+    QVERIFY(e.preview(Function::Forward, poly));
     QVERIFY(poly.size() == 128);
     for (i = 0; i < 128; i++)
         if (poly[i].y() > max)


remove spurrious CHECK

remove spurrious CHECK

--- constraint_solver/constraints.cc
+++ constraint_solver/constraints.cc
@@ -262,7 +262,6 @@
                                                active_.get(),
                                                size_);
     visitor->VisitIntegerArgument(this, "assume_paths", assume_paths_);
-    CHECK(sink_handler_ == NULL);
     // TODO(user) : VISITOR -> sink_handler
     visitor->EndVisitConstraint(ModelVisitor::kNoCycle, this);
   }


fixed describer of name changed command

fixed describer of name changed command

--- src/application/setups/editor/gui/editor_all_entities_gui.cpp
+++ src/application/setups/editor/gui/editor_all_entities_gui.cpp
@@ -58,6 +58,7 @@
    	const editor_command_input in
 ) {
 	thread_local std::optional<ImGuiID> last_active;
+	thread_local std::string cached_old_description;

 	auto& history = in.folder.history;

@@ -124,41 +125,47 @@
 		);
 	};

+	struct description_pair {
+		std::string of_old;
+		std::string of_new;
+	};
+
 	auto describe_changed = [&](
 		const auto& field_name,
 		const auto& old_value,
 	   	const auto& new_value
-	) {
+	) -> description_pair {
 		using F = std::decay_t<decltype(new_value)>;

 		if constexpr(std::is_same_v<F, bool>) {
-			return describe_changed_flag(field_name, new_value);
+			return { "", describe_changed_flag(field_name, new_value) };
 		}
 		else {
 			if (field_name == "Name") {
-				return typesafe_sprintf(
-					"Renamed %x to %x",
-					old_value,
-					new_value
-				);
-			}
-
-			return describe_changed_generic(
+				return {
+					typesafe_sprintf("Renamed %x ", old_value),
+					typesafe_sprintf("to %x ", new_value)
+				};
+			}
+
+			return { "", describe_changed_generic(
 				field_name,
 				new_value
-			);
+			) };
 		}
 	};

 	auto post_new_change = [&](
-		const auto& description,
+		const description_pair& description,
 	   	const auto& new_content
 	) {
+		cached_old_description = description.of_old;
+
 		change_flavour_property_command cmd;
 		cmd.property_id = make_property_id();

 		cmd.value_after_change = augs::to_bytes(new_content);
-		cmd.built_description = description;
+		cmd.built_description = cached_old_description + description.of_new;
 		history.execute_new(cmd, in);
 	};

@@ -169,7 +176,7 @@
 		auto& last = history.last_command();

 		if (auto* const cmd = std::get_if<change_flavour_property_command>(std::addressof(last))) {
-			cmd->built_description = description;
+			cmd->built_description = cached_old_description + description;
 			cmd->rewrite_change(augs::to_bytes(new_content), in);
 		}
 		else {
@@ -195,7 +202,7 @@
 			}
 			else {
 				/* LOG("Dragging %x to %x", label, member); */
-				rewrite_last_change(description, new_value);
+				rewrite_last_change(description.of_new, new_value);
 			}

 			last_active = this_id;
@@ -278,7 +285,7 @@
 				auto do_flag = [&](const auto& flag_name, auto& flag) {
 					if (checkbox(flag_name, flag)) {
 						post_new_change(
-							describe_changed_flag(flag_name, flag),
+							{ "", describe_changed_flag(flag_name, flag) },
 							altered_member
 						);
 					}


bugfix

bugfix

--- eeschema/sch_sheet_pin.cpp
+++ eeschema/sch_sheet_pin.cpp
@@ -23,6 +23,7 @@
 #include "general.h"
 #include "protos.h"
 #include "sch_sheet.h"
+#include "kicad_string.h"

 /* m_Edge define on which edge the pin is positionned:
@@ -253,19 +254,45 @@

 bool SCH_SHEET_PIN::Load( LINE_READER& aLine, wxString& aErrorMsg )
 {
-    int  size;
-    char number[256];
-    char name[256];
-    char connectType[256];
-    char sheetSide[256];
-
-    /* Read coordinates. */
-    if( sscanf( ((char*)aLine), "%s %s %s %s %d %d %d",
-                number, name, connectType, sheetSide, &m_Pos.x, &m_Pos.y, &size ) != 7 )
+    int     size;
+    char    number[256];
+    char    name[256];
+    char    connectType[256];
+    char    sheetSide[256];
+    char*   line = aLine.Line();
+    char*   cp;
+
+    static const char delims[] = " \t";
+
+    // Read coordinates.
+    D( printf( "line: \"%s\"\n", line );)
+
+    cp = strtok( line, delims );
+
+    strncpy( number, cp, sizeof(number) );
+    number[sizeof(number)-1] = 0;
+
+    cp += strlen( number ) + 1;
+
+    cp += ReadDelimitedText( name, cp, sizeof(name) );
+
+    cp = strtok( cp, delims );
+    strncpy( connectType, cp, sizeof(connectType) );
+    connectType[sizeof(connectType)-1] = 0;
+
+    cp = strtok( NULL, delims );
+    strncpy( sheetSide, cp, sizeof(sheetSide) );
+    sheetSide[sizeof(sheetSide)-1] = 0;
+
+    cp += strlen( sheetSide ) + 1;
+
+    int r = sscanf( cp, "%d %d %d", &m_Pos.x, &m_Pos.y, &size );
+    if( r != 3 )
     {
         aErrorMsg.Printf( wxT( "EESchema file sheet hierarchical label error at line %d.\n" ),
                           aLine.LineNumber() );
-        aErrorMsg << FROM_UTF8( ((char*)aLine) );
+
+        aErrorMsg << FROM_UTF8( line );
         return false;
     }


[test] Avoid potential NULL pointer dereference in addrman_tests.cpp

--- src/test/addrman_tests.cpp
+++ src/test/addrman_tests.cpp
@@ -297,7 +297,7 @@
     // Test 18; Find does not discriminate by port number.
     CAddrInfo* info2 = addrman.Find(addr2);
     BOOST_CHECK(info2);
-    if (info2)
+    if (info2 && info1)
         BOOST_CHECK(info2->ToString() == info1->ToString());

     // Test 19: Find returns another IP matching what we searched on.


Fix Flash sandbox regression from r87093.

BUG=84348
Review URL: http://codereview.chromium.org/7104005

git-svn-id: de016e52bd170d2d4f2344f9bf92d50478b649e0@87364 0039d316-1c4b-4281-b951-d872f2087c98

--- content/common/sandbox_policy.cc
+++ content/common/sandbox_policy.cc
@@ -396,7 +396,6 @@
       !browser_command_line.HasSwitch(switches::kNoSandbox) &&
       content::GetContentClient()->SandboxPlugin(cmd_line, policy)) {
     in_sandbox = true;
-    AddDllEvictionPolicy(policy);
   }

   if (!in_sandbox) {
@@ -405,7 +404,9 @@
     return process;
   }

-  if (type == ChildProcessInfo::GPU_PROCESS) {
+  if (type == ChildProcessInfo::PLUGIN_PROCESS) {
+    AddDllEvictionPolicy(policy);
+  } else if (type == ChildProcessInfo::GPU_PROCESS) {
     if (!AddPolicyForGPU(cmd_line, policy))
       return 0;
   } else if (type == ChildProcessInfo::PPAPI_PLUGIN_PROCESS) {


FIX: now the user supplied value for gaussian standard deviation is used.

--- Core/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
+++ Core/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
@@ -172,7 +172,7 @@
     //threshold->Delete();
     gaussian->SetDimensionality( 3  );
     gaussian->SetRadiusFactor( 0.49 );
-    gaussian->SetStandardDeviation( 1.5 );
+    gaussian->SetStandardDeviation( GetGaussianStandardDeviation() );
     gaussian->ReleaseDataFlagOn();
     gaussian->UpdateInformation();
     gaussian->Update();


Fix unsigned/signed comparison in master_tests

Review: https://reviews.apache.org/r/30678

--- src/tests/master_tests.cpp
+++ src/tests/master_tests.cpp
@@ -2881,7 +2881,7 @@
   EXPECT_SOME(portsArray);

   JSON::Array portsArray_ = portsArray.get();
-  EXPECT_EQ(2, portsArray_.values.size());
+  EXPECT_EQ(2u, portsArray_.values.size());

   // Verify the content of '8888:myport1:tcp' port.
   Try<JSON::Value> expected = JSON::parse(
@@ -2909,7 +2909,7 @@
   EXPECT_SOME(labelsArray);

   JSON::Array labelsArray_ = labelsArray.get();
-  EXPECT_EQ(2, labelsArray_.values.size());
+  EXPECT_EQ(2u, labelsArray_.values.size());

   // Verify the content of 'clearance:high' pair.
   expected = JSON::parse(


Use a format string for debug logging.

Use a format string for debug logging.

--- src/tests/platform/log.cpp
+++ src/tests/platform/log.cpp
@@ -3,7 +3,7 @@
 #include <stdarg.h>

 void openxc::util::log::debugUart(const char* message) {
-    printf(message);
+    printf("%s", message);
 }

 void openxc::util::log::initialize() { }


Fix bug in fire compare

Fix bug in fire compare

--- src/tests/test_manager.cpp
+++ src/tests/test_manager.cpp
@@ -19,7 +19,7 @@
 	if (!r) {
 		return pair<bool, string>{false, "Failed to open " + right};
 	}
-
+
 	l.seekg(ios::end, 0);
 	r.seekg(ios::end, 0);

@@ -43,7 +43,7 @@
 			return pair<bool, string>{false, "Failed to read same sizes from both files"};
 		}

-		if (!memcmp(buffer[0].get(), buffer[1].get(), r.gcount())) {
+		if (memcmp(buffer[0].get(), buffer[1].get(), r.gcount()) != 0) {
 			return pair<bool, string>{false, "Data missmatch in files!"};
 		}
 	}


BUG: crasinh on 64 bit vista system. Try rearranging output iterator --.

--- Examples/Iterators/ImageLinearIteratorWithIndex.cxx
+++ Examples/Iterators/ImageLinearIteratorWithIndex.cxx
@@ -201,12 +201,11 @@
     {
     inputIt.GoToBeginOfLine();
     outputIt.GoToEndOfLine();
-    --outputIt;
     while ( ! inputIt.IsAtEndOfLine() )
       {
+      --outputIt;
       outputIt.Set( inputIt.Get() );
       ++inputIt;
-      --outputIt;
       }
     }
 // Software Guide : EndCodeSnippet


add pipeline cache

add pipeline cache

--- GameEngineCore/VulkanAPI/VulkanHardwareRenderer.cpp
+++ GameEngineCore/VulkanAPI/VulkanHardwareRenderer.cpp
@@ -190,6 +190,8 @@
 		int transferQueueIndex;
 		vk::Queue renderQueue;
 		vk::Queue transferQueue;
+
+		vk::PipelineCache pipelineCache;

 		CoreLib::RefPtr<CoreLib::List<DescriptorPoolObject*>> descriptorPoolChain;

@@ -437,6 +439,12 @@
 			CreateDevice();
 			CreateCommandPool();
 			CreateDescriptorPoolChain();
+
+			vk::PipelineCacheCreateInfo createInfo = vk::PipelineCacheCreateInfo()
+				.setInitialDataSize(0)
+				.setPInitialData(nullptr);
+
+			State().pipelineCache = State().device.createPipelineCache(createInfo);
 		}

 		static void Init()
@@ -487,6 +495,7 @@
 		static void UninitDevice()
 		{
 			State().device.waitIdle();
+			State().device.destroyPipelineCache(State().pipelineCache);
 			DestroyDescriptorPoolChain();
 			DestroyCommandPool();
 			DestroyDevice();
@@ -560,6 +569,11 @@
 		static const vk::Queue& RenderQueue()
 		{
 			return State().renderQueue;
+		}
+
+		static const vk::PipelineCache& PipelineCache()
+		{
+			return State().pipelineCache;
 		}

 		static std::pair<const vk::CommandBuffer, const vk::Fence> PrimaryBuffer()
@@ -3166,7 +3180,7 @@
 			.setBasePipelineHandle(vk::Pipeline())
 			.setBasePipelineIndex(-1);

-		this->pipeline = RendererState::Device().createGraphicsPipelines(vk::PipelineCache(), pipelineCreateInfo)[0];
+		this->pipeline = RendererState::Device().createGraphicsPipelines(RendererState::PipelineCache(), pipelineCreateInfo)[0];

 //#if _DEBUG
 //		vk::DebugMarkerObjectNameInfoEXT nameInfo = vk::DebugMarkerObjectNameInfoEXT()


Remove iterators from BBLShift to remove a spurious(?) warning when running in g++'s debug mode. i.e. with -D_GLIBCXX_DEBUG

--- src/to-sat/BitBlastNew.cpp
+++ src/to-sat/BitBlastNew.cpp
@@ -739,13 +739,12 @@
 void BitBlasterNew::BBLShift(BBNodeVec& x, unsigned int shift) {
 	// left shift x (destructively) within width.
 	// loop backwards so that copy to self works correctly. (DON'T use STL insert!)
-	const BBNodeVec::iterator xbeg = x.begin();
-	BBNodeVec::iterator xit = x.end() - 1;
-	for (; xit >= xbeg; xit--) {
-		if (xit - shift >= xbeg)
-			*xit = *(xit - shift);
+	for (int i =((int)x.size())-1; i >=0; i--)
+	{
+		if (i-(int)shift >= 0)
+			x[i] = x[i-(int)shift];
 		else
-			*xit = nf->getFalse(); // new LSB is zero.
+			x[i] = nf->getFalse(); // new LSB is zero.
 	}
 }


D3D10 render system fix - Fixed an assert that was reported by psquare, the is the suggested solution by lordofcoder. Read more about it here on this thread: http://www.ogre3d.org/forums/viewtopic.php?f=4&t=36493&start=325

--- RenderSystems/Direct3D10/src/OgreD3D10HLSLProgram.cpp
+++ RenderSystems/Direct3D10/src/OgreD3D10HLSLProgram.cpp
@@ -480,7 +480,7 @@
 	//-----------------------------------------------------------------------
 	void D3D10HLSLProgram::populateDef(D3D10_SHADER_TYPE_DESC& d3dDesc, GpuConstantDefinition& def) const
 	{
-		def.arraySize = d3dDesc.Elements;
+		def.arraySize = d3dDesc.Elements + 1;
 		switch(d3dDesc.Type)
 		{
 		case D3D10_SVT_INT:
@@ -618,12 +618,15 @@
 		SAFE_RELEASE(mConstantBuffer);

 		// this is a hack - to solve that problem that we are the mAssemblerProgram of ourselves
-		*(mAssemblerProgram.useCountPointer()) = 0;
-		mAssemblerProgram.setNull();
+		if ( !mAssemblerProgram.isNull() )
+		{
+			*( mAssemblerProgram.useCountPointer() ) = 0;
+			mAssemblerProgram.setNull();
+		}

 		// have to call this here reather than in Resource destructor
 		// since calling virtual methods in base destructors causes crash
-		if (isLoaded())
+		if ( isLoaded() )
 		{
 			unload();
 		}


Fixed PaStiX::comm_size() implementation

--- amgcl/mpi/pastix.hpp
+++ amgcl/mpi/pastix.hpp
@@ -60,7 +60,8 @@
         struct params {};

         static int comm_size(int n_global_rows) {
-            return std::max(1, n_global_rows / 5000);
+            const int dofs_per_process = 5000;
+            return (n_global_rows + dofs_per_process - 1) / dofs_per_process;
         }

         template <class PRng, class CRng, class VRng>