FCL/sf/mw/qt: comparison tests/auto/qgl/tst

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 void getSetCheck();
 void openGLVersionCheck();
 void graphicsViewClipping();
 void partialGLWidgetUpdates_data();
 void partialGLWidgetUpdates();
+void glWidgetWithAlpha();
 void glWidgetRendering();
+void glFBOSimpleRendering();
 void glFBORendering();
 void multipleFBOInterleavedRendering();
 void glFBOUseInGLWidget();
 void glPBufferRendering();
 void glWidgetReparent();
 void glWidgetRenderPixmap();
-void stackedFBOs();
 void colormap();
 void fboFormat();
 void testDontCrashOnDanglingResources();
 void replaceClipping();
 void clipTest();
 public:
 MyGLWidget() : QGLWidget() {}
 bool autoBufferSwap() const { return QGLWidget::autoBufferSwap(); }
 void setAutoBufferSwap(bool on) { QGLWidget::setAutoBufferSwap(on); }
 };
+static int appDefaultDepth()
+{
+static int depth = 0;
+if (depth == 0) {
+QPixmap pm(1, 1);
+depth = pm.depth();
+}
+return depth;
+}
 // Using INT_MIN and INT_MAX will cause failures on systems
 // where "int" is 64-bit, so use the explicit values instead.
 #define TEST_INT_MIN    (-2147483647 - 1)
 #define TEST_INT_MAX    2147483647
 obj1.setStencilBufferSize(TEST_INT_MAX);
 QCOMPARE(TEST_INT_MAX, obj1.stencilBufferSize());
 // bool QGLFormat::sampleBuffers()
 // void QGLFormat::setSampleBuffers(bool)
-#if !defined(QT_OPENGL_ES_2)
 QCOMPARE(false, obj1.sampleBuffers());
 QVERIFY(!obj1.testOption(QGL::SampleBuffers));
 QVERIFY(obj1.testOption(QGL::NoSampleBuffers));
-#else
-QCOMPARE(true, obj1.sampleBuffers());
-QVERIFY(obj1.testOption(QGL::SampleBuffers));
-QVERIFY(!obj1.testOption(QGL::NoSampleBuffers));
-#endif
 obj1.setSampleBuffers(false);
 QCOMPARE(false, obj1.sampleBuffers());
 QVERIFY(obj1.testOption(QGL::NoSampleBuffers));
 obj1.setSampleBuffers(true);
 QCOMPARE(true, obj1.sampleBuffers());
 QVERIFY(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_1);
 #endif //defined(QT_OPENGL_ES_1)
 #endif //QT_BUILD_INTERNAL
 }
+static bool fuzzyComparePixels(const QRgb testPixel, const QRgb refPixel, const char* file, int line, int x = -1, int y = -1)
+{
+static int maxFuzz = 1;
+static bool maxFuzzSet = false;
+// On 16 bpp systems, we need to allow for more fuzz:
+if (!maxFuzzSet) {
+maxFuzzSet = true;
+if (appDefaultDepth() < 24)
+maxFuzz = 32;
+}
+int redFuzz = qAbs(qRed(testPixel) - qRed(refPixel));
+int greenFuzz = qAbs(qGreen(testPixel) - qGreen(refPixel));
+int blueFuzz = qAbs(qBlue(testPixel) - qBlue(refPixel));
+int alphaFuzz = qAbs(qAlpha(testPixel) - qAlpha(refPixel));
+if (refPixel != 0 && testPixel == 0) {
+QString msg;
+if (x >= 0) {
+msg = QString("Test pixel [%1, %2] is null (black) when it should be (%3,%4,%5,%6)")
+.arg(x).arg(y)
+.arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel));
+} else {
+msg = QString("Test pixel is null (black) when it should be (%2,%3,%4,%5)")
+.arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel));
+}
+QTest::qFail(msg.toLatin1(), file, line);
+return false;
+}
+if (redFuzz > maxFuzz || greenFuzz > maxFuzz || blueFuzz > maxFuzz || alphaFuzz > maxFuzz) {
+QString msg;
+if (x >= 0)
+msg = QString("Pixel [%1,%2]: ").arg(x).arg(y);
+else
+msg = QString("Pixel ");
+msg += QString("Max fuzz (%1) exceeded: (%2,%3,%4,%5) vs (%6,%7,%8,%9)")
+.arg(maxFuzz)
+.arg(qRed(testPixel)).arg(qGreen(testPixel)).arg(qBlue(testPixel)).arg(qAlpha(testPixel))
+.arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel));
+QTest::qFail(msg.toLatin1(), file, line);
+return false;
+}
+return true;
+}
+static void fuzzyCompareImages(const QImage &testImage, const QImage &referenceImage, const char* file, int line)
+{
+QCOMPARE(testImage.width(), referenceImage.width());
+QCOMPARE(testImage.height(), referenceImage.height());
+for (int y = 0; y < testImage.height(); y++) {
+for (int x = 0; x < testImage.width(); x++) {
+if (!fuzzyComparePixels(testImage.pixel(x, y), referenceImage.pixel(x, y), file, line, x, y)) {
+// Might as well save the images for easier debugging:
+referenceImage.save("referenceImage.png");
+testImage.save("testImage.png");
+return;
+}
+}
+}
+}
+#define QFUZZY_COMPARE_IMAGES(A,B) \
+fuzzyCompareImages(A, B, __FILE__, __LINE__)
+#define QFUZZY_COMPARE_PIXELS(A,B) \
+fuzzyComparePixels(A, B, __FILE__, __LINE__)
 class UnclippedWidget : public QWidget
 {
 public:
 void paintEvent(QPaintEvent *)
 {
 QGraphicsScene scene;
 scene.addWidget(widget)->setPos(0, 0);
 QGraphicsView view(&scene);
+#ifdef Q_WS_QWS
+view.setWindowFlags(Qt::FramelessWindowHint);
+#endif
 view.resize(2*size, 2*size);
 QGLWidget *viewport = new QGLWidget;
 view.setViewport(viewport);
 view.show();
 QPainter p(&expected);
 p.fillRect(expected.rect(), Qt::white);
 p.fillRect(QRect(0, 0, size, size), Qt::black);
 p.end();
-QCOMPARE(image, expected);
+QFUZZY_COMPARE_IMAGES(image, expected);
 }
 void tst_QGL::partialGLWidgetUpdates_data()
 {
 QTest::addColumn<bool>("doubleBufferedContext");
 p.begin(&reference);
 p.fillRect(0, 0, 128, 128, Qt::red);
 p.fillRect(32, 32, 64, 64, Qt::blue);
 p.end();
-QCOMPARE(fb, reference);
+QFUZZY_COMPARE_IMAGES(fb, reference);
+}
+void tst_QGL::glWidgetWithAlpha()
+{
+QGLWidget* w = new QGLWidget(QGLFormat(QGL::AlphaChannel));
+w->show();
+#ifdef Q_WS_X11
+qt_x11_wait_for_window_manager(w);
+#endif
+delete w;
 }
 class GLWidget : public QGLWidget
 {
 public:
 QPaintEngine* pe = p.paintEngine();
 engineType = pe->type();
 // This test only ensures it's possible to paint onto a QGLWidget. Full
 // paint engine feature testing is way out of scope!
+p.fillRect(-1, -1, width()+2, height()+2, Qt::red);
-p.fillRect(0, 0, width(), height(), Qt::red);
 // No p.end() or swap buffers, should be done automatically
 }
 };
 void tst_QGL::glWidgetRendering()
 {
 GLWidget w;
+#ifdef Q_WS_QWS
+w.setWindowFlags(Qt::FramelessWindowHint);
+#endif
+w.setGeometry(100, 100, 200, 200);
 w.show();
 #ifdef Q_WS_X11
 qt_x11_wait_for_window_manager(&w);
 #endif
 QImage fb = w.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
 QImage reference(fb.size(), QImage::Format_RGB32);
 reference.fill(0xffff0000);
-QCOMPARE(fb, reference);
+QFUZZY_COMPARE_IMAGES(fb, reference);
+}
+void tst_QGL::glFBOSimpleRendering()
+{
+if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
+QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
+QGLWidget glw;
+glw.makeCurrent();
+// No multisample with combined depth/stencil attachment:
+QGLFramebufferObjectFormat fboFormat;
+fboFormat.setAttachment(QGLFramebufferObject::NoAttachment);
+// Don't complicate things by using NPOT:
+QGLFramebufferObject *fbo = new QGLFramebufferObject(256, 128, fboFormat);
+fbo->bind();
+glClearColor(1.0, 0.0, 0.0, 1.0);
+glClear(GL_COLOR_BUFFER_BIT);
+glFinish();
+QImage fb = fbo->toImage().convertToFormat(QImage::Format_RGB32);
+QImage reference(fb.size(), QImage::Format_RGB32);
+reference.fill(0xffff0000);
+QFUZZY_COMPARE_IMAGES(fb, reference);
+delete fbo;
 }
 // NOTE: This tests that CombinedDepthStencil attachment works by assuming the
 //       GL2 engine is being used and is implemented the same way as it was when
 //       this autotest was written. If this is not the case, there may be some
 delete fbo;
 // As we're doing more than trivial painting, we can't just compare to
 // an image rendered with raster. Instead, we sample at well-defined
 // test-points:
-QCOMPARE(fb.pixel(39, 64), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(39, 64), QColor(Qt::red).rgb());
-QCOMPARE(fb.pixel(89, 64), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(89, 64), QColor(Qt::red).rgb());
-QCOMPARE(fb.pixel(64, 39), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(64, 39), QColor(Qt::blue).rgb());
-QCOMPARE(fb.pixel(64, 89), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(64, 89), QColor(Qt::blue).rgb());
-QCOMPARE(fb.pixel(167, 39), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(167, 39), QColor(Qt::red).rgb());
-QCOMPARE(fb.pixel(217, 39), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(217, 39), QColor(Qt::red).rgb());
-QCOMPARE(fb.pixel(192, 64), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb.pixel(192, 64), QColor(Qt::green).rgb());
 }
 // Tests multiple QPainters active on different FBOs at the same time, with
 // interleaving painting. Performance-wise, this is sub-optimal, but it still
 delete fbo3;
 // As we're doing more than trivial painting, we can't just compare to
 // an image rendered with raster. Instead, we sample at well-defined
 // test-points:
-QCOMPARE(fb1.pixel(39, 64), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(39, 64), QColor(Qt::red).rgb());
-QCOMPARE(fb1.pixel(89, 64), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(89, 64), QColor(Qt::red).rgb());
-QCOMPARE(fb1.pixel(64, 39), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(64, 39), QColor(Qt::blue).rgb());
-QCOMPARE(fb1.pixel(64, 89), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(64, 89), QColor(Qt::blue).rgb());
-QCOMPARE(fb1.pixel(167, 39), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(167, 39), QColor(Qt::red).rgb());
-QCOMPARE(fb1.pixel(217, 39), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(217, 39), QColor(Qt::red).rgb());
-QCOMPARE(fb1.pixel(192, 64), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb1.pixel(192, 64), QColor(Qt::green).rgb());
-QCOMPARE(fb2.pixel(39, 64), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(39, 64), QColor(Qt::green).rgb());
-QCOMPARE(fb2.pixel(89, 64), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(89, 64), QColor(Qt::green).rgb());
-QCOMPARE(fb2.pixel(64, 39), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(64, 39), QColor(Qt::red).rgb());
-QCOMPARE(fb2.pixel(64, 89), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(64, 89), QColor(Qt::red).rgb());
-QCOMPARE(fb2.pixel(167, 39), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(167, 39), QColor(Qt::green).rgb());
-QCOMPARE(fb2.pixel(217, 39), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(217, 39), QColor(Qt::green).rgb());
-QCOMPARE(fb2.pixel(192, 64), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb2.pixel(192, 64), QColor(Qt::blue).rgb());
-QCOMPARE(fb3.pixel(39, 64), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(39, 64), QColor(Qt::blue).rgb());
-QCOMPARE(fb3.pixel(89, 64), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(89, 64), QColor(Qt::blue).rgb());
-QCOMPARE(fb3.pixel(64, 39), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(64, 39), QColor(Qt::green).rgb());
-QCOMPARE(fb3.pixel(64, 89), QColor(Qt::green).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(64, 89), QColor(Qt::green).rgb());
-QCOMPARE(fb3.pixel(167, 39), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(167, 39), QColor(Qt::blue).rgb());
-QCOMPARE(fb3.pixel(217, 39), QColor(Qt::blue).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(217, 39), QColor(Qt::blue).rgb());
-QCOMPARE(fb3.pixel(192, 64), QColor(Qt::red).rgb());
+QFUZZY_COMPARE_PIXELS(fb3.pixel(192, 64), QColor(Qt::red).rgb());
 }
 class FBOUseInGLWidget : public QGLWidget
 {
 public:
 fboFormat.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
 QGLFramebufferObject *fbo = new QGLFramebufferObject(128, 128, fboFormat);
 QPainter fboPainter;
 fboPainterBeginOk = fboPainter.begin(fbo);
-fboPainter.fillRect(0, 0, 128, 128, Qt::red);
+fboPainter.fillRect(-1, -1, 130, 130, Qt::red);
 fboPainter.end();
 fboImage = fbo->toImage();
-widgetPainter.fillRect(rect(), Qt::blue);
+widgetPainter.fillRect(-1, -1, width()+2, width()+2, Qt::blue);
 delete fbo;
 }
 };
 {
 if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
 QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
 FBOUseInGLWidget w;
+#ifdef Q_WS_QWS
+w.setWindowFlags(Qt::FramelessWindowHint);
+#endif
 w.resize(128, 128);
 w.show();
 #ifdef Q_WS_X11
 qt_x11_wait_for_window_manager(&w);
 QVERIFY(w.fboPainterBeginOk);
 QImage widgetFB = w.grabFrameBuffer(false);
 QImage widgetReference(widgetFB.size(), widgetFB.format());
 widgetReference.fill(0xff0000ff);
-QCOMPARE(widgetFB, widgetReference);
+QFUZZY_COMPARE_IMAGES(widgetFB, widgetReference);
 QImage fboReference(w.fboImage.size(), w.fboImage.format());
 fboReference.fill(0xffff0000);
-QCOMPARE(w.fboImage, fboReference);
+QFUZZY_COMPARE_IMAGES(w.fboImage, fboReference);
 }
 void tst_QGL::glWidgetReparent()
 {
 // Try it as a top-level first:
 QImage fb = pm.toImage().convertToFormat(QImage::Format_RGB32);
 QImage reference(fb.size(), QImage::Format_RGB32);
 reference.fill(0xffff0000);
-QCOMPARE(fb, reference);
+QFUZZY_COMPARE_IMAGES(fb, reference);
 }
-// When using multiple FBOs at the same time, unbinding one FBO should re-bind the
-// previous. I.e. It should be possible to have a stack of FBOs where pop'ing there
-// top re-binds the one underneeth.
-void tst_QGL::stackedFBOs()
-{
-if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
-QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
-QGLWidget glw;
-glw.show();
-#ifdef Q_WS_X11
-qt_x11_wait_for_window_manager(&glw);
-#endif
-QTest::qWait(200);
-glw.makeCurrent();
-// No multisample with combined depth/stencil attachment:
-QGLFramebufferObjectFormat fboFormat;
-fboFormat.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
-// Don't complicate things by using NPOT:
-QGLFramebufferObject *fbo1 = new QGLFramebufferObject(128, 128, fboFormat);
-QGLFramebufferObject *fbo2 = new QGLFramebufferObject(128, 128, fboFormat);
-QGLFramebufferObject *fbo3 = new QGLFramebufferObject(128, 128, fboFormat);
-glClearColor(1.0, 0.0, 1.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-fbo1->bind();
-glClearColor(1.0, 0.0, 0.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-fbo2->bind();
-glClearColor(0.0, 1.0, 0.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-fbo3->bind();
-glClearColor(0.0, 0.0, 1.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-glScissor(32, 32, 64, 64);
-glEnable(GL_SCISSOR_TEST);
-glClearColor(0.0, 1.0, 1.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-fbo3->release();
-// Scissor rect & test should be left untouched by the fbo release...
-glClearColor(0.0, 0.0, 0.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-fbo2->release();
-glClearColor(1.0, 1.0, 1.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-fbo1->release();
-glClearColor(1.0, 1.0, 0.0, 1.0);
-glClear(GL_COLOR_BUFFER_BIT);
-glw.swapBuffers();
-QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
-QImage fb1 = fbo1->toImage().convertToFormat(QImage::Format_RGB32);
-QImage fb2 = fbo2->toImage().convertToFormat(QImage::Format_RGB32);
-QImage fb3 = fbo3->toImage().convertToFormat(QImage::Format_RGB32);
-delete fbo1;
-delete fbo2;
-delete fbo3;
-QImage widgetReference(widgetFB.size(), widgetFB.format());
-QImage fb1Reference(fb1.size(), fb1.format());
-QImage fb2Reference(fb2.size(), fb2.format());
-QImage fb3Reference(fb3.size(), fb3.format());
-QPainter widgetReferencePainter(&widgetReference);
-QPainter fb1ReferencePainter(&fb1Reference);
-QPainter fb2ReferencePainter(&fb2Reference);
-QPainter fb3ReferencePainter(&fb3Reference);
-widgetReferencePainter.fillRect(0, 0, widgetReference.width(), widgetReference.height(), Qt::magenta);
-fb1ReferencePainter.fillRect(0, 0, fb1Reference.width(), fb1Reference.height(), Qt::red);
-fb2ReferencePainter.fillRect(0, 0, fb2Reference.width(), fb2Reference.height(), Qt::green);
-fb3ReferencePainter.fillRect(0, 0, fb3Reference.width(), fb3Reference.height(), Qt::blue);
-// Flip y-coords to match GL for the widget (which can be any size)
-widgetReferencePainter.fillRect(32, glw.height() - 96, 64, 64, Qt::yellow);
-fb1ReferencePainter.fillRect(32, 32, 64, 64, Qt::white);
-fb2ReferencePainter.fillRect(32, 32, 64, 64, Qt::black);
-fb3ReferencePainter.fillRect(32, 32, 64, 64, Qt::cyan);
-widgetReferencePainter.end();
-fb1ReferencePainter.end();
-fb2ReferencePainter.end();
-fb3ReferencePainter.end();
-QCOMPARE(widgetFB, widgetReference);
-QCOMPARE(fb1, fb1Reference);
-QCOMPARE(fb2, fb2Reference);
-QCOMPARE(fb3, fb3Reference);
-}
 class ColormapExtended : public QGLColormap
 {
 public:
 ColormapExtended() {}
 };
 void tst_QGL::replaceClipping()
 {
 ReplaceClippingGLWidget glw;
+#ifdef Q_WS_QWS
+glw.setWindowFlags(Qt::FramelessWindowHint);
+#endif
 glw.resize(300, 300);
 glw.show();
 #ifdef Q_WS_X11
 qt_x11_wait_for_window_manager(&glw);
 glw.paint(&referencePainter);
 referencePainter.end();
 const QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
-QCOMPARE(widgetFB, reference);
+// Sample pixels in a grid pattern which avoids false failures due to
+// off-by-one pixel errors on some buggy GL implementations
+for (int x = 25; x < reference.width(); x += 50) {
+for (int y = 25; y < reference.width(); y += 50) {
+QFUZZY_COMPARE_PIXELS(widgetFB.pixel(x, y), reference.pixel(x, y));
+}
+}
 }
 class ClipTestGLWidget : public QGLWidget
 {
 public:
 void paint(QPainter *painter)
 {
-painter->fillRect(rect(), Qt::white);
+painter->fillRect(-1, -1, width()+2, height()+2, Qt::white);
 painter->setClipRect(10, 10, width()-20, height()-20);
 painter->fillRect(rect(), Qt::cyan);
 painter->save();
 painter->setClipRect(10, 10, 100, 100, Qt::IntersectClip);
 };
 void tst_QGL::clipTest()
 {
 ClipTestGLWidget glw;
+#ifdef Q_WS_QWS
+glw.setWindowFlags(Qt::FramelessWindowHint);
+#endif
 glw.resize(220, 220);
 glw.show();
 #ifdef Q_WS_X11
 qt_x11_wait_for_window_manager(&glw);
 glw.paint(&referencePainter);
 referencePainter.end();
 const QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
-QCOMPARE(widgetFB, reference);
+// Sample pixels in a grid pattern which avoids false failures due to
+// off-by-one pixel errors on some buggy GL implementations
+for (int x = 2; x < reference.width(); x += 5) {
+for (int y = 2; y < reference.width(); y += 5) {
+QFUZZY_COMPARE_PIXELS(widgetFB.pixel(x, y), reference.pixel(x, y));
+}
+}
 }
 void tst_QGL::destroyFBOAfterContext()
 {
 if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
 QVERIFY(!qt_shared_test()->value(glw1->context()));
 qt_shared_test()->insert(glw1->context(), res1);
 QVERIFY(qt_shared_test()->value(glw1->context()) == res1);
 // Create another context that shares with the first.
+QVERIFY(!glw1->isSharing());
 QGLWidget *glw2 = new QGLWidget(0, glw1);
 if (!glw2->isSharing()) {
 delete glw2;
 delete glw1;
 QSKIP("Context sharing is not supported", SkipSingle);
 }
+QVERIFY(glw1->isSharing());
 QVERIFY(glw1->context() != glw2->context());
 // Check that the first context's resource is also on the second.
 QVERIFY(qt_shared_test()->value(glw1->context()) == res1);
 QVERIFY(qt_shared_test()->value(glw2->context()) == res1);
 QVERIFY(!QGLContext::areSharing(glw1->context(), 0));
 QVERIFY(!QGLContext::areSharing(0, 0));
 // Create a third context, not sharing with the others.
 QGLWidget *glw3 = new QGLWidget();
+QVERIFY(!glw3->isSharing());
 // Create a guard on the standalone context.
 QGLSharedResourceGuard guard3(glw3->context());
 guard3.setId(5);
 QVERIFY(guard.id() == 3);
 // Delete the first context.
 delete glw1;
+// The second context should no longer register as sharing.
+QVERIFY(!glw2->isSharing());
 // The first context's resource should transfer to the second context.
 QCOMPARE(tst_QGLResource::deletions, 0);
 QVERIFY(qt_shared_test()->value(glw2->context()) == res1);
 QVERIFY(qt_shared_test()->value(glw3->context()) == res3);

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c
child 18	2f34d5167611