/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qcoreapplication.h>

#include <qdebug.h>

#include <qgl.h>

#include <qglpixelbuffer.h>

#include <qglframebufferobject.h>

#include <qglcolormap.h>

#include <qpaintengine.h>

#include <QGraphicsView>

#include <QGraphicsProxyWidget>

#include <QVBoxLayout>

#ifdef QT_BUILD_INTERNAL

#include <QtOpenGL/private/qgl_p.h>

#include <QtGui/private/qpixmapdata_p.h>

#include <QtGui/private/qimage_p.h>

#include <QtGui/private/qimagepixmapcleanuphooks_p.h>

#endif

//TESTED_CLASS=

//TESTED_FILES=

class tst_QGL : public QObject

{

Q_OBJECT

public:

    tst_QGL();

    virtual ~tst_QGL();

private slots:

    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 colormap();

    void fboFormat();

    void testDontCrashOnDanglingResources();

    void replaceClipping();

    void clipTest();

    void destroyFBOAfterContext();

    void shareRegister();

    void qglContextDefaultBindTexture();

    void textureCleanup();

};

tst_QGL::tst_QGL()

{

}

tst_QGL::~tst_QGL()

{

}

class MyGLContext : public QGLContext

{

public:

    MyGLContext(const QGLFormat& format) : QGLContext(format) {}

    bool windowCreated() const { return QGLContext::windowCreated(); }

    void setWindowCreated(bool on) { QGLContext::setWindowCreated(on); }

    bool initialized() const { return QGLContext::initialized(); }

    void setInitialized(bool on) { QGLContext::setInitialized(on); }

};

class MyGLWidget : public QGLWidget

{

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

// Testing get/set functions

void tst_QGL::getSetCheck()

{

    if (!QGLFormat::hasOpenGL())

        QSKIP("QGL not supported on this platform", SkipAll);

    QGLFormat obj1;

    // int QGLFormat::depthBufferSize()

    // void QGLFormat::setDepthBufferSize(int)

    QCOMPARE(-1, obj1.depthBufferSize());

    obj1.setDepthBufferSize(0);

    QCOMPARE(0, obj1.depthBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setDepthBufferSize: Cannot set negative depth buffer size -2147483648");

    obj1.setDepthBufferSize(TEST_INT_MIN);

    QCOMPARE(0, obj1.depthBufferSize()); // Makes no sense with a negative buffer size

    obj1.setDepthBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setDepthBufferSize: Cannot set negative depth buffer size -1");

    obj1.setDepthBufferSize(-1);

    QCOMPARE(3, obj1.depthBufferSize());

    obj1.setDepthBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.depthBufferSize());

    // int QGLFormat::accumBufferSize()

    // void QGLFormat::setAccumBufferSize(int)

    QCOMPARE(-1, obj1.accumBufferSize());

    obj1.setAccumBufferSize(0);

    QCOMPARE(0, obj1.accumBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setAccumBufferSize: Cannot set negative accumulate buffer size -2147483648");

    obj1.setAccumBufferSize(TEST_INT_MIN);

    QCOMPARE(0, obj1.accumBufferSize()); // Makes no sense with a negative buffer size

    obj1.setAccumBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setAccumBufferSize: Cannot set negative accumulate buffer size -1");

    obj1.setAccumBufferSize(-1);

    QCOMPARE(3, obj1.accumBufferSize());

    obj1.setAccumBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.accumBufferSize());

    // int QGLFormat::redBufferSize()

    // void QGLFormat::setRedBufferSize(int)

    QCOMPARE(-1, obj1.redBufferSize());

    obj1.setRedBufferSize(0);

    QCOMPARE(0, obj1.redBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setRedBufferSize: Cannot set negative red buffer size -2147483648");

    obj1.setRedBufferSize(TEST_INT_MIN);

    QCOMPARE(0, obj1.redBufferSize()); // Makes no sense with a negative buffer size

    obj1.setRedBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setRedBufferSize: Cannot set negative red buffer size -1");

    obj1.setRedBufferSize(-1);

    QCOMPARE(3, obj1.redBufferSize());

    obj1.setRedBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.redBufferSize());

    // int QGLFormat::greenBufferSize()

    // void QGLFormat::setGreenBufferSize(int)

    QCOMPARE(-1, obj1.greenBufferSize());

    obj1.setGreenBufferSize(0);

    QCOMPARE(0, obj1.greenBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setGreenBufferSize: Cannot set negative green buffer size -2147483648");

    obj1.setGreenBufferSize(TEST_INT_MIN);

    QCOMPARE(0, obj1.greenBufferSize()); // Makes no sense with a negative buffer size

    obj1.setGreenBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setGreenBufferSize: Cannot set negative green buffer size -1");

    obj1.setGreenBufferSize(-1);

    QCOMPARE(3, obj1.greenBufferSize());

    obj1.setGreenBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.greenBufferSize());

    // int QGLFormat::blueBufferSize()

    // void QGLFormat::setBlueBufferSize(int)

    QCOMPARE(-1, obj1.blueBufferSize());

    obj1.setBlueBufferSize(0);

    QCOMPARE(0, obj1.blueBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setBlueBufferSize: Cannot set negative blue buffer size -2147483648");

    obj1.setBlueBufferSize(TEST_INT_MIN);

    QCOMPARE(0, obj1.blueBufferSize()); // Makes no sense with a negative buffer size

    obj1.setBlueBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setBlueBufferSize: Cannot set negative blue buffer size -1");

    obj1.setBlueBufferSize(-1);

    QCOMPARE(3, obj1.blueBufferSize());

    obj1.setBlueBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.blueBufferSize());

    // int QGLFormat::alphaBufferSize()

    // void QGLFormat::setAlphaBufferSize(int)

    QCOMPARE(-1, obj1.alphaBufferSize());

    QCOMPARE(false, obj1.alpha());

    QVERIFY(!obj1.testOption(QGL::AlphaChannel));

    QVERIFY(obj1.testOption(QGL::NoAlphaChannel));

    obj1.setAlphaBufferSize(1);

    QCOMPARE(true, obj1.alpha());   // setAlphaBufferSize() enables alpha.

    QCOMPARE(1, obj1.alphaBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setAlphaBufferSize: Cannot set negative alpha buffer size -2147483648");

    obj1.setAlphaBufferSize(TEST_INT_MIN);

    QCOMPARE(1, obj1.alphaBufferSize()); // Makes no sense with a negative buffer size

    obj1.setAlphaBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setAlphaBufferSize: Cannot set negative alpha buffer size -1");

    obj1.setAlphaBufferSize(-1);

    QCOMPARE(3, obj1.alphaBufferSize());

    obj1.setAlphaBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.alphaBufferSize());

    // int QGLFormat::stencilBufferSize()

    // void QGLFormat::setStencilBufferSize(int)

    QCOMPARE(-1, obj1.stencilBufferSize());

    obj1.setStencilBufferSize(1);

    QCOMPARE(1, obj1.stencilBufferSize());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setStencilBufferSize: Cannot set negative stencil buffer size -2147483648");

    obj1.setStencilBufferSize(TEST_INT_MIN);

    QCOMPARE(1, obj1.stencilBufferSize()); // Makes no sense with a negative buffer size

    obj1.setStencilBufferSize(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setStencilBufferSize: Cannot set negative stencil buffer size -1");

    obj1.setStencilBufferSize(-1);

    QCOMPARE(3, obj1.stencilBufferSize());

    obj1.setStencilBufferSize(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.stencilBufferSize());

    // bool QGLFormat::sampleBuffers()

    // void QGLFormat::setSampleBuffers(bool)

    QCOMPARE(false, obj1.sampleBuffers());

    QVERIFY(!obj1.testOption(QGL::SampleBuffers));

    QVERIFY(obj1.testOption(QGL::NoSampleBuffers));

    obj1.setSampleBuffers(false);

    QCOMPARE(false, obj1.sampleBuffers());

    QVERIFY(obj1.testOption(QGL::NoSampleBuffers));

    obj1.setSampleBuffers(true);

    QCOMPARE(true, obj1.sampleBuffers());

    QVERIFY(obj1.testOption(QGL::SampleBuffers));

    // int QGLFormat::samples()

    // void QGLFormat::setSamples(int)

    QCOMPARE(-1, obj1.samples());

    obj1.setSamples(0);

    QCOMPARE(0, obj1.samples());

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setSamples: Cannot have negative number of samples per pixel -2147483648");

    obj1.setSamples(TEST_INT_MIN);

    QCOMPARE(0, obj1.samples());  // Makes no sense with a negative sample size

    obj1.setSamples(3);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setSamples: Cannot have negative number of samples per pixel -1");

    obj1.setSamples(-1);

    QCOMPARE(3, obj1.samples());

    obj1.setSamples(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.samples());

    // int QGLFormat::swapInterval()

    // void QGLFormat::setSwapInterval(int)

    QCOMPARE(-1, obj1.swapInterval());

    obj1.setSwapInterval(0);

    QCOMPARE(0, obj1.swapInterval());

    obj1.setSwapInterval(TEST_INT_MIN);

    QCOMPARE(TEST_INT_MIN, obj1.swapInterval());

    obj1.setSwapInterval(-1);

    QCOMPARE(-1, obj1.swapInterval());

    obj1.setSwapInterval(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.swapInterval());

    // bool QGLFormat::doubleBuffer()

    // void QGLFormat::setDoubleBuffer(bool)

    QCOMPARE(true, obj1.doubleBuffer());

    QVERIFY(obj1.testOption(QGL::DoubleBuffer));

    QVERIFY(!obj1.testOption(QGL::SingleBuffer));

    obj1.setDoubleBuffer(false);

    QCOMPARE(false, obj1.doubleBuffer());

    QVERIFY(!obj1.testOption(QGL::DoubleBuffer));

    QVERIFY(obj1.testOption(QGL::SingleBuffer));

    obj1.setDoubleBuffer(true);

    QCOMPARE(true, obj1.doubleBuffer());

    QVERIFY(obj1.testOption(QGL::DoubleBuffer));

    QVERIFY(!obj1.testOption(QGL::SingleBuffer));

    // bool QGLFormat::depth()

    // void QGLFormat::setDepth(bool)

    QCOMPARE(true, obj1.depth());

    QVERIFY(obj1.testOption(QGL::DepthBuffer));

    QVERIFY(!obj1.testOption(QGL::NoDepthBuffer));

    obj1.setDepth(false);

    QCOMPARE(false, obj1.depth());

    QVERIFY(!obj1.testOption(QGL::DepthBuffer));

    QVERIFY(obj1.testOption(QGL::NoDepthBuffer));

    obj1.setDepth(true);

    QCOMPARE(true, obj1.depth());

    QVERIFY(obj1.testOption(QGL::DepthBuffer));

    QVERIFY(!obj1.testOption(QGL::NoDepthBuffer));

    // bool QGLFormat::rgba()

    // void QGLFormat::setRgba(bool)

    QCOMPARE(true, obj1.rgba());

    QVERIFY(obj1.testOption(QGL::Rgba));

    QVERIFY(!obj1.testOption(QGL::ColorIndex));

    obj1.setRgba(false);

    QCOMPARE(false, obj1.rgba());

    QVERIFY(!obj1.testOption(QGL::Rgba));

    QVERIFY(obj1.testOption(QGL::ColorIndex));

    obj1.setRgba(true);

    QCOMPARE(true, obj1.rgba());

    QVERIFY(obj1.testOption(QGL::Rgba));

    QVERIFY(!obj1.testOption(QGL::ColorIndex));

    // bool QGLFormat::alpha()

    // void QGLFormat::setAlpha(bool)

    QVERIFY(obj1.testOption(QGL::AlphaChannel));

    QVERIFY(!obj1.testOption(QGL::NoAlphaChannel));

    obj1.setAlpha(false);

    QCOMPARE(false, obj1.alpha());

    QVERIFY(!obj1.testOption(QGL::AlphaChannel));

    QVERIFY(obj1.testOption(QGL::NoAlphaChannel));

    obj1.setAlpha(true);

    QCOMPARE(true, obj1.alpha());

    QVERIFY(obj1.testOption(QGL::AlphaChannel));

    QVERIFY(!obj1.testOption(QGL::NoAlphaChannel));

    // bool QGLFormat::accum()

    // void QGLFormat::setAccum(bool)

    obj1.setAccumBufferSize(0);

    QCOMPARE(false, obj1.accum());

    QVERIFY(!obj1.testOption(QGL::AccumBuffer));

    QVERIFY(obj1.testOption(QGL::NoAccumBuffer));

    obj1.setAccum(false);

    QCOMPARE(false, obj1.accum());

    QVERIFY(!obj1.testOption(QGL::AccumBuffer));

    QVERIFY(obj1.testOption(QGL::NoAccumBuffer));

    obj1.setAccum(true);

    QCOMPARE(true, obj1.accum());

    QVERIFY(obj1.testOption(QGL::AccumBuffer));

    QVERIFY(!obj1.testOption(QGL::NoAccumBuffer));

    // bool QGLFormat::stencil()

    // void QGLFormat::setStencil(bool)

    QCOMPARE(true, obj1.stencil());

    QVERIFY(obj1.testOption(QGL::StencilBuffer));

    QVERIFY(!obj1.testOption(QGL::NoStencilBuffer));

    obj1.setStencil(false);

    QCOMPARE(false, obj1.stencil());

    QVERIFY(!obj1.testOption(QGL::StencilBuffer));

    QVERIFY(obj1.testOption(QGL::NoStencilBuffer));

    obj1.setStencil(true);

    QCOMPARE(true, obj1.stencil());

    QVERIFY(obj1.testOption(QGL::StencilBuffer));

    QVERIFY(!obj1.testOption(QGL::NoStencilBuffer));

    // bool QGLFormat::stereo()

    // void QGLFormat::setStereo(bool)

    QCOMPARE(false, obj1.stereo());

    QVERIFY(!obj1.testOption(QGL::StereoBuffers));

    QVERIFY(obj1.testOption(QGL::NoStereoBuffers));

    obj1.setStereo(false);

    QCOMPARE(false, obj1.stereo());

    QVERIFY(!obj1.testOption(QGL::StereoBuffers));

    QVERIFY(obj1.testOption(QGL::NoStereoBuffers));

    obj1.setStereo(true);

    QCOMPARE(true, obj1.stereo());

    QVERIFY(obj1.testOption(QGL::StereoBuffers));

    QVERIFY(!obj1.testOption(QGL::NoStereoBuffers));

    // bool QGLFormat::directRendering()

    // void QGLFormat::setDirectRendering(bool)

    QCOMPARE(true, obj1.directRendering());

    QVERIFY(obj1.testOption(QGL::DirectRendering));

    QVERIFY(!obj1.testOption(QGL::IndirectRendering));

    obj1.setDirectRendering(false);

    QCOMPARE(false, obj1.directRendering());

    QVERIFY(!obj1.testOption(QGL::DirectRendering));

    QVERIFY(obj1.testOption(QGL::IndirectRendering));

    obj1.setDirectRendering(true);

    QCOMPARE(true, obj1.directRendering());

    QVERIFY(obj1.testOption(QGL::DirectRendering));

    QVERIFY(!obj1.testOption(QGL::IndirectRendering));

    // bool QGLFormat::overlay()

    // void QGLFormat::setOverlay(bool)

    QCOMPARE(false, obj1.hasOverlay());

    QVERIFY(!obj1.testOption(QGL::HasOverlay));

    QVERIFY(obj1.testOption(QGL::NoOverlay));

    obj1.setOverlay(false);

    QCOMPARE(false, obj1.hasOverlay());

    QVERIFY(!obj1.testOption(QGL::HasOverlay));

    QVERIFY(obj1.testOption(QGL::NoOverlay));

    obj1.setOverlay(true);

    QCOMPARE(true, obj1.hasOverlay());

    QVERIFY(obj1.testOption(QGL::HasOverlay));

    QVERIFY(!obj1.testOption(QGL::NoOverlay));

    // int QGLFormat::plane()

    // void QGLFormat::setPlane(int)

    QCOMPARE(0, obj1.plane());

    obj1.setPlane(0);

    QCOMPARE(0, obj1.plane());

    obj1.setPlane(TEST_INT_MIN);

    QCOMPARE(TEST_INT_MIN, obj1.plane());

    obj1.setPlane(TEST_INT_MAX);

    QCOMPARE(TEST_INT_MAX, obj1.plane());

    // int QGLFormat::major/minorVersion()

    // void QGLFormat::setVersion(int, int)

    QCOMPARE(obj1.majorVersion(), 1);

    QCOMPARE(obj1.minorVersion(), 0);

    obj1.setVersion(3, 2);

    QCOMPARE(obj1.majorVersion(), 3);

    QCOMPARE(obj1.minorVersion(), 2);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setVersion: Cannot set zero or negative version number 0.1");

    obj1.setVersion(0, 1);

    QCOMPARE(obj1.majorVersion(), 3);

    QCOMPARE(obj1.minorVersion(), 2);

    QTest::ignoreMessage(QtWarningMsg, "QGLFormat::setVersion: Cannot set zero or negative version number 3.-1");

    obj1.setVersion(3, -1);

    QCOMPARE(obj1.majorVersion(), 3);

    QCOMPARE(obj1.minorVersion(), 2);

    obj1.setVersion(TEST_INT_MAX, TEST_INT_MAX - 1);

    QCOMPARE(obj1.majorVersion(), TEST_INT_MAX);

    QCOMPARE(obj1.minorVersion(), TEST_INT_MAX - 1);

    // operator== and operator!= for QGLFormat

    QGLFormat format1;

    QGLFormat format2;

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setDoubleBuffer(false);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setDoubleBuffer(false);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setDepthBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setDepthBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setAccumBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setAccumBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setRedBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setRedBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setGreenBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setGreenBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setBlueBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setBlueBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setAlphaBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setAlphaBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setStencilBufferSize(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setStencilBufferSize(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setSamples(8);

    QVERIFY(!(format1 == format2));

    QVERIFY(format1 != format2);

    format2.setSamples(8);

    QVERIFY(format1 == format2);

    QVERIFY(!(format1 != format2));

    format1.setSwapInterval(8);

    QVERIFY(!(format1 == format2));