summaryrefslogtreecommitdiffstats
path: root/tests/auto
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto')
-rw-r--r--tests/auto/auto.pro2
-rw-r--r--tests/auto/qgl_threads/qgl_threads.pro11
-rw-r--r--tests/auto/qgl_threads/tst_openglthreading.cpp468
-rw-r--r--tests/auto/qgl_threads/tst_openglthreading.h61
-rw-r--r--tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp57
-rw-r--r--tests/auto/qpathclipper/tst_qpathclipper.cpp18
-rw-r--r--tests/auto/qprinter/tst_qprinter.cpp10
-rw-r--r--tests/auto/qstatictext/qstatictext.pro4
-rw-r--r--tests/auto/qstatictext/tst_qstatictext.cpp437
9 files changed, 1055 insertions, 13 deletions
diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 9c4b4f0..a02e8da 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -462,7 +462,7 @@ SUBDIRS += \
rcc \
windowsmobile
-contains(QT_CONFIG,opengl):SUBDIRS += qgl qglbuffer
+contains(QT_CONFIG,opengl):SUBDIRS += qgl qglbuffer qgl_threads
contains(QT_CONFIG,qt3support):!wince*:SUBDIRS += $$Q3SUBDIRS
diff --git a/tests/auto/qgl_threads/qgl_threads.pro b/tests/auto/qgl_threads/qgl_threads.pro
new file mode 100644
index 0000000..9312c05
--- /dev/null
+++ b/tests/auto/qgl_threads/qgl_threads.pro
@@ -0,0 +1,11 @@
+############################################################
+# Project file for autotest for file qgl.h
+############################################################
+
+load(qttest_p4)
+requires(contains(QT_CONFIG,opengl))
+QT += opengl
+
+HEADERS += tst_openglthreading.h
+SOURCES += tst_openglthreading.cpp
+
diff --git a/tests/auto/qgl_threads/tst_openglthreading.cpp b/tests/auto/qgl_threads/tst_openglthreading.cpp
new file mode 100644
index 0000000..6634869
--- /dev/null
+++ b/tests/auto/qgl_threads/tst_openglthreading.cpp
@@ -0,0 +1,468 @@
+/****************************************************************************
+**
+** 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 <QtCore/QtCore>
+#include <QtGui/QtGui>
+#include <QtOpenGL/QtOpenGL>
+#include "tst_openglthreading.h"
+
+#ifdef Q_WS_X11
+#include <private/qt_x11_p.h>
+#endif
+
+#define RUNNING_TIME 5000
+
+tst_OpenGLThreading::tst_OpenGLThreading(QObject *parent)
+ : QObject(parent)
+{
+}
+
+
+
+/*
+
+ swapInThread
+
+ The purpose of this testcase is to verify that it is possible to do rendering into
+ a GL context from the GUI thread, then swap the contents in from a background thread.
+
+ The usecase for this is to have the background thread do the waiting for vertical
+ sync while the GUI thread is idle.
+
+ Currently the locking is handled directly in the paintEvent(). For the actual usecase
+ in Qt, the locking is done in the windowsurface before starting any drawing while
+ unlocking is done after all drawing has been done.
+ */
+
+
+class SwapThread : public QThread
+{
+ Q_OBJECT
+public:
+ SwapThread(QGLWidget *widget)
+ : m_widget(widget)
+ {
+ moveToThread(this);
+ }
+
+ void run() {
+ QTime time;
+ time.start();
+ while (time.elapsed() < RUNNING_TIME) {
+ lock();
+ wait();
+
+ m_widget->makeCurrent();
+ m_widget->swapBuffers();
+ m_widget->doneCurrent();
+ unlock();
+ }
+ }
+
+ void lock() { m_mutex.lock(); }
+ void unlock() { m_mutex.unlock(); }
+
+ void wait() { m_wait_condition.wait(&m_mutex); }
+ void notify() { m_wait_condition.wakeAll(); }
+
+private:
+ QGLWidget *m_widget;
+ QMutex m_mutex;
+ QWaitCondition m_wait_condition;
+};
+
+class ForegroundWidget : public QGLWidget
+{
+public:
+ ForegroundWidget(const QGLFormat &format)
+ : QGLWidget(format), m_thread(0)
+ {
+ setAutoBufferSwap(false);
+ }
+
+ void paintEvent(QPaintEvent *)
+ {
+ m_thread->lock();
+ makeCurrent();
+ QPainter p(this);
+ p.fillRect(rect(), QColor(rand() % 256, rand() % 256, rand() % 256));
+ p.setPen(Qt::red);
+ p.setFont(QFont("SansSerif", 24));
+ p.drawText(rect(), Qt::AlignCenter, "This is an autotest");
+ p.end();
+ doneCurrent();
+ m_thread->notify();
+ m_thread->unlock();
+
+ update();
+ }
+
+ void setThread(SwapThread *thread) {
+ m_thread = thread;
+ }
+
+ SwapThread *m_thread;
+};
+
+void tst_OpenGLThreading::swapInThread()
+{
+ QGLFormat format;
+ format.setSwapInterval(1);
+ ForegroundWidget widget(format);
+ SwapThread thread(&widget);
+ widget.setThread(&thread);
+ widget.show();
+
+ QTest::qWaitForWindowShown(&widget);
+ thread.start();
+
+ while (thread.isRunning()) {
+ qApp->processEvents();
+ }
+
+ widget.hide();
+
+ QVERIFY(true);
+}
+
+
+
+
+
+
+
+/*
+ textureUploadInThread
+
+ The purpose of this testcase is to verify that doing texture uploads in a background
+ thread is possible and that it works.
+ */
+
+class CreateAndUploadThread : public QThread
+{
+ Q_OBJECT
+public:
+ CreateAndUploadThread(QGLWidget *shareWidget)
+ {
+ m_gl = new QGLWidget(0, shareWidget);
+ moveToThread(this);
+ }
+
+ ~CreateAndUploadThread()
+ {
+ delete m_gl;
+ }
+
+ void run() {
+ m_gl->makeCurrent();
+ QTime time;
+ time.start();
+ while (time.elapsed() < RUNNING_TIME) {
+ QImage image(400, 300, QImage::Format_RGB32);
+ QPainter p(&image);
+ p.fillRect(image.rect(), QColor(rand() % 256, rand() % 256, rand() % 256));
+ p.setPen(Qt::red);
+ p.setFont(QFont("SansSerif", 24));
+ p.drawText(image.rect(), Qt::AlignCenter, "This is an autotest");
+ p.end();
+ m_gl->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
+ createdAndUploaded(image);
+ }
+ }
+
+signals:
+ void createdAndUploaded(const QImage &image);
+
+private:
+ QGLWidget *m_gl;
+};
+
+class TextureDisplay : public QGLWidget
+{
+ Q_OBJECT
+public:
+ void paintEvent(QPaintEvent *) {
+ QPainter p(this);
+ for (int i=0; i<m_images.size(); ++i) {
+ p.drawImage(m_positions.at(i), m_images.at(i));
+ m_positions[i] += QPoint(1, 1);
+ }
+ update();
+ }
+
+public slots:
+ void receiveImage(const QImage &image) {
+ m_images << image;
+ m_positions << QPoint(-rand() % width() / 2, -rand() % height() / 2);
+
+ if (m_images.size() > 100) {
+ m_images.takeFirst();
+ m_positions.takeFirst();
+ }
+ }
+
+private:
+ QList <QImage> m_images;
+ QList <QPoint> m_positions;
+};
+
+void tst_OpenGLThreading::textureUploadInThread()
+{
+ TextureDisplay display;
+ CreateAndUploadThread thread(&display);
+
+ connect(&thread, SIGNAL(createdAndUploaded(QImage)), &display, SLOT(receiveImage(QImage)));
+
+ display.show();
+ QTest::qWaitForWindowShown(&display);
+
+ thread.start();
+
+ while (thread.isRunning()) {
+ qApp->processEvents();
+ }
+
+ QVERIFY(true);
+}
+
+
+
+
+
+
+/*
+ renderInThread
+
+ This test sets up a scene and renders it in a different thread.
+ For simplicity, the scene is simply a bunch of rectangles, but
+ if that works, we're in good shape..
+ */
+
+static inline float qrandom() { return (rand() % 100) / 100.f; }
+
+void renderAScene(int w, int h)
+{
+#ifdef QT_OPENGL_ES_2
+ QGLShaderProgram program;
+ program.addShaderFromSourceCode(QGLShader::Vertex, "attribute highp vec2 pos; void main() { gl_Position = vec4(pos.xy, 1.0, 1.0); }");
+ program.addShaderFromSourceCode(QGLShader::Fragment, "uniform lowp vec4 color; void main() { gl_FragColor = color; }");
+ program.bindAttributeLocation("pos", 0);
+ program.bind();
+ int colorId = program.uniformLocation("color");
+
+ glEnableVertexAttribArray(0);
+
+ for (int i=0; i<1000; ++i) {
+ GLfloat pos[] = {
+ (rand() % 100) / 100.,
+ (rand() % 100) / 100.,
+ (rand() % 100) / 100.,
+ (rand() % 100) / 100.,
+ (rand() % 100) / 100.,
+ (rand() % 100) / 100.
+ };
+
+ glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, pos);
+ glDrawArrays(GL_TRIANGLE_STRIP, 0, 3);
+ }
+#else
+ glViewport(0, 0, w, h);
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glFrustum(0, w, h, 0, 1, 100);
+ glTranslated(0, 0, -1);
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ for (int i=0;i<1000; ++i) {
+ glBegin(GL_TRIANGLES);
+ glColor3f(qrandom(), qrandom(), qrandom());
+ glVertex2f(qrandom() * w, qrandom() * h);
+ glColor3f(qrandom(), qrandom(), qrandom());
+ glVertex2f(qrandom() * w, qrandom() * h);
+ glColor3f(qrandom(), qrandom(), qrandom());
+ glVertex2f(qrandom() * w, qrandom() * h);
+ glEnd();
+ }
+#endif
+}
+
+class ThreadSafeGLWidget : public QGLWidget
+{
+public:
+ void paintEvent(QPaintEvent *)
+ {
+ // ignored as we're anyway swapping as fast as we can
+ };
+
+ void resizeEvent(QResizeEvent *e)
+ {
+ mutex.lock();
+ newSize = e->size();
+ mutex.unlock();
+ };
+
+ QMutex mutex;
+ QSize newSize;
+};
+
+class SceneRenderingThread : public QThread
+{
+ Q_OBJECT
+public:
+ SceneRenderingThread(ThreadSafeGLWidget *widget)
+ : m_widget(widget)
+ {
+ moveToThread(this);
+ m_size = widget->size();
+ }
+
+ void run() {
+ QTime time;
+ time.start();
+ failure = false;
+
+ m_widget->makeCurrent();
+
+ while (time.elapsed() < RUNNING_TIME && !failure) {
+
+
+ m_widget->mutex.lock();
+ QSize s = m_widget->newSize;
+ m_widget->mutex.unlock();
+
+ if (s != m_size) {
+ glViewport(0, 0, s.width(), s.height());
+ }
+
+ if (QGLContext::currentContext() != m_widget->context()) {
+ failure = true;
+ break;
+ }
+
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ int w = m_widget->width();
+ int h = m_widget->height();
+
+ renderAScene(w, h);
+
+ int color;
+ glReadPixels(w / 2, h / 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &color);
+
+ m_widget->swapBuffers();
+ }
+
+ m_widget->doneCurrent();
+ }
+
+ bool failure;
+
+private:
+ ThreadSafeGLWidget *m_widget;
+ QSize m_size;
+};
+
+void tst_OpenGLThreading::renderInThread_data()
+{
+ QTest::addColumn<bool>("resize");
+ QTest::addColumn<bool>("update");
+
+ QTest::newRow("basic") << false << false;
+ QTest::newRow("with-resize") << true << false;
+ QTest::newRow("with-update") << false << true;
+ QTest::newRow("with-resize-and-update") << true << true;
+}
+
+void tst_OpenGLThreading::renderInThread()
+{
+ QFETCH(bool, resize);
+ QFETCH(bool, update);
+
+ ThreadSafeGLWidget widget;
+ widget.resize(200, 200);
+ SceneRenderingThread thread(&widget);
+
+ widget.show();
+ QTest::qWaitForWindowShown(&widget);
+ widget.doneCurrent();
+
+ thread.start();
+
+ int value = 10;
+ while (thread.isRunning()) {
+ if (resize)
+ widget.resize(200 + value, 200 + value);
+ if (update)
+ widget.update(100 + value, 100 + value, 20, 20);
+ qApp->processEvents();
+ value = -value;
+
+#ifdef Q_WS_WIN
+ Sleep(100);
+#else
+ usleep(100 * 1000);
+#endif
+ }
+
+ QVERIFY(!thread.failure);
+}
+
+
+
+
+int main(int argc, char **argv)
+{
+#ifdef Q_WS_X11
+ XInitThreads();
+#endif
+
+ QApplication app(argc, argv);
+ QTEST_DISABLE_KEYPAD_NAVIGATION \
+
+ tst_OpenGLThreading tc;
+ return QTest::qExec(&tc, argc, argv);
+}
+
+#include "tst_openglthreading.moc"
diff --git a/tests/auto/qgl_threads/tst_openglthreading.h b/tests/auto/qgl_threads/tst_openglthreading.h
new file mode 100644
index 0000000..c4b55cd
--- /dev/null
+++ b/tests/auto/qgl_threads/tst_openglthreading.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TST_OPENGLTHREADING_H
+#define TST_OPENGLTHREADING_H
+
+#include <QObject>
+
+class tst_OpenGLThreading : public QObject
+{
+Q_OBJECT
+public:
+ explicit tst_OpenGLThreading(QObject *parent = 0);
+
+private slots:
+ void swapInThread();
+ void textureUploadInThread();
+
+ void renderInThread_data();
+ void renderInThread();
+};
+
+#endif // TST_OPENGLTHREADING_H
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 7c1b97e..269ec24 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -438,6 +438,7 @@ private slots:
void QTBUG_6738_missingUpdateWithSetParent();
void QTBUG_7714_fullUpdateDiscardingOpacityUpdate2();
void QT_2653_fullUpdateDiscardingOpacityUpdate();
+ void QT_2649_focusScope();
private:
QList<QGraphicsItem *> paintedItems;
@@ -10002,5 +10003,61 @@ void tst_QGraphicsItem::QTBUG_7714_fullUpdateDiscardingOpacityUpdate2()
QTRY_COMPARE(view.repaints, 1);
}
+void tst_QGraphicsItem::QT_2649_focusScope()
+{
+ QGraphicsScene *scene = new QGraphicsScene;
+
+ QGraphicsRectItem *subFocusItem = new QGraphicsRectItem;
+ subFocusItem->setFlags(QGraphicsItem::ItemIsFocusable);
+ subFocusItem->setFocus();
+ QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+
+ QGraphicsRectItem *scope = new QGraphicsRectItem;
+ scope->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemIsFocusScope);
+ scope->setFocus();
+ subFocusItem->setParentItem(scope);
+ QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+ QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+
+ QGraphicsRectItem *rootItem = new QGraphicsRectItem;
+ rootItem->setFlags(QGraphicsItem::ItemIsFocusable);
+ scope->setParentItem(rootItem);
+ QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+ QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+ QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+
+ scene->addItem(rootItem);
+
+ QEvent windowActivate(QEvent::WindowActivate);
+ qApp->sendEvent(scene, &windowActivate);
+ scene->setFocus();
+
+ QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(scope->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+ QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+ QVERIFY(subFocusItem->hasFocus());
+
+ //If we hide the focusScope, the entire subFocus chain should be cleared
+ scope->hide();
+
+ QCOMPARE(rootItem->focusItem(), (QGraphicsItem *)0);
+ QCOMPARE(scope->focusItem(), (QGraphicsItem *)0);
+ QCOMPARE(subFocusItem->focusItem(), (QGraphicsItem *)0);
+ QCOMPARE(rootItem->focusScopeItem(), (QGraphicsItem *)0);
+ QCOMPARE(scope->focusScopeItem(), (QGraphicsItem *)subFocusItem);
+ QCOMPARE(subFocusItem->focusScopeItem(), (QGraphicsItem *)0);
+ QVERIFY(!subFocusItem->hasFocus());
+
+ delete scene;
+}
+
QTEST_MAIN(tst_QGraphicsItem)
#include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qpathclipper/tst_qpathclipper.cpp b/tests/auto/qpathclipper/tst_qpathclipper.cpp
index 5b49545..9e37988 100644
--- a/tests/auto/qpathclipper/tst_qpathclipper.cpp
+++ b/tests/auto/qpathclipper/tst_qpathclipper.cpp
@@ -336,13 +336,17 @@ static QPainterPath samplePath13()
static QPainterPath samplePath14()
{
QPainterPath path;
- path.moveTo(QPointF(100, 180));
- path.lineTo(QPointF(100, 80));
- path.lineTo(QPointF(120, 80));
- path.lineTo(QPointF(120, 100));
- path.lineTo(QPointF(160, 100));
- path.lineTo(QPointF(160, 180));
- path.lineTo(QPointF(100, 180));
+
+ path.moveTo(160, 80);
+ path.lineTo(160, 180);
+ path.lineTo(100, 180);
+ path.lineTo(100, 80);
+ path.lineTo(160, 80);
+ path.moveTo(160, 80);
+ path.lineTo(160, 100);
+ path.lineTo(120, 100);
+ path.lineTo(120, 80);
+
return path;
}
diff --git a/tests/auto/qprinter/tst_qprinter.cpp b/tests/auto/qprinter/tst_qprinter.cpp
index b1ff425..7e8ce84 100644
--- a/tests/auto/qprinter/tst_qprinter.cpp
+++ b/tests/auto/qprinter/tst_qprinter.cpp
@@ -106,7 +106,7 @@ private slots:
void testCustomPageSizes();
void printDialogCompleter();
- void testActualNumCopies();
+ void testCopyCount();
void taskQTBUG4497_reusePrinterOnDifferentFiles();
@@ -455,7 +455,7 @@ void tst_QPrinter::testNonExistentPrinter()
printer.pageSize();
printer.orientation();
printer.fullPage();
- printer.setNumCopies(1);
+ printer.setCopyCount(1);
printer.printerName();
// nor metrics
@@ -966,11 +966,11 @@ void tst_QPrinter::printDialogCompleter()
#endif
}
-void tst_QPrinter::testActualNumCopies()
+void tst_QPrinter::testCopyCount()
{
QPrinter p;
- p.setNumCopies(15);
- QCOMPARE(p.actualNumCopies(), 15);
+ p.setCopyCount(15);
+ QCOMPARE(p.copyCount(), 15);
}
static void printPage(QPainter *painter)
diff --git a/tests/auto/qstatictext/qstatictext.pro b/tests/auto/qstatictext/qstatictext.pro
new file mode 100644
index 0000000..a759a90
--- /dev/null
+++ b/tests/auto/qstatictext/qstatictext.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+QT = core gui opengl
+SOURCES += tst_qstatictext.cpp
+
diff --git a/tests/auto/qstatictext/tst_qstatictext.cpp b/tests/auto/qstatictext/tst_qstatictext.cpp
new file mode 100644
index 0000000..c826b05
--- /dev/null
+++ b/tests/auto/qstatictext/tst_qstatictext.cpp
@@ -0,0 +1,437 @@
+/****************************************************************************
+**
+** 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 <QtGui/QApplication>
+#include <QtGui/QPainter>
+#include <QtGui/QImage>
+
+#include <QtOpenGl/QGLWidget>
+
+#include <qstatictext.h>
+#include <private/qstatictext_p.h>
+
+// #define DEBUG_SAVE_IMAGE
+
+class tst_QStaticText: public QObject
+{
+ Q_OBJECT
+private slots:
+ void init();
+ void cleanup();
+
+ void constructionAndDestruction();
+ void drawToPoint_data();
+ void drawToPoint();
+ void drawToRect_data();
+ void drawToRect();
+ void setFont();
+ void setMaximumSize();
+ void prepareToCorrectData();
+ void prepareToWrongData();
+
+ void translatedPainter();
+ void rotatedPainter();
+ void scaledPainter();
+ void projectedPainter();
+ void rotatedScaledAndTranslatedPainter();
+ void transformationChanged();
+};
+
+void tst_QStaticText::init()
+{
+}
+
+void tst_QStaticText::cleanup()
+{
+}
+
+void tst_QStaticText::constructionAndDestruction()
+{
+ QStaticText text("My text");
+}
+
+Q_DECLARE_METATYPE(QStaticText::PerformanceHint)
+void tst_QStaticText::drawToPoint_data()
+{
+ QTest::addColumn<QStaticText::PerformanceHint>("performanceHint");
+
+ QTest::newRow("Moderate caching") << QStaticText::ModerateCaching;
+ QTest::newRow("Aggressive caching") << QStaticText::AggressiveCaching;
+}
+
+void tst_QStaticText::drawToPoint()
+{
+ QFETCH(QStaticText::PerformanceHint, performanceHint);
+
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ text.setPerformanceHint(performanceHint);
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::drawToRect_data()
+{
+ QTest::addColumn<QStaticText::PerformanceHint>("performanceHint");
+
+ QTest::newRow("Moderate caching") << QStaticText::ModerateCaching;
+ QTest::newRow("Aggressive caching") << QStaticText::AggressiveCaching;
+}
+
+void tst_QStaticText::drawToRect()
+{
+ QFETCH(QStaticText::PerformanceHint, performanceHint);
+
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.drawText(QRectF(11, 12, 10, 500), "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", QSizeF(10, 500));
+ text.setPerformanceHint(performanceHint);
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::prepareToCorrectData()
+{
+ QTransform transform;
+ transform.scale(2.0, 2.0);
+ transform.rotate(90, Qt::ZAxis);
+
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.setTransform(transform);
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ p.setTransform(transform);
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ text.prepare(transform, p.font());
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::prepareToWrongData()
+{
+ QTransform transform;
+ transform.scale(2.0, 2.0);
+ transform.rotate(90, Qt::ZAxis);
+
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ text.prepare(transform, p.font());
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+
+void tst_QStaticText::setFont()
+{
+ QFont font = QApplication::font();
+ font.setBold(true);
+ font.setPointSize(28);
+
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.drawText(0, 0, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+
+ p.setFont(font);
+ p.drawText(11, 120, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+
+ QStaticText text;
+ text.setText("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+
+ p.drawStaticText(0, 0, text);
+
+ p.setFont(font);
+ p.drawStaticText(11, 120, text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::setMaximumSize()
+{
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.drawText(QRectF(11, 12, 10, 500), "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ text.setMaximumSize(QSizeF(10, 500));
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::translatedPainter()
+{
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.translate(100, 200);
+
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ p.translate(100, 200);
+
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::rotatedPainter()
+{
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.rotate(30.0);
+ p.drawText(0, 0, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+
+ QPainter p(&imageDrawStaticText);
+ p.rotate(30.0);
+ p.drawStaticText(QPoint(0, 0), text);
+ }
+
+#if defined(DEBUG_SAVE_IMAGE)
+ imageDrawText.save("rotatedPainter_imageDrawText.png");
+ imageDrawStaticText.save("rotatedPainter_imageDrawStaticText.png");
+#endif
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::scaledPainter()
+{
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.scale(2.0, 0.2);
+
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ p.scale(2.0, 0.2);
+
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::projectedPainter()
+{
+ QTransform transform;
+ transform.rotate(90, Qt::XAxis);
+
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.setTransform(transform);
+
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ p.setTransform(transform);
+
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+
+}
+
+void tst_QStaticText::rotatedScaledAndTranslatedPainter()
+{
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.rotate(45.0);
+ p.scale(2.0, 2.0);
+ p.translate(100, 200);
+
+ p.drawText(11, 12, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ p.rotate(45.0);
+ p.scale(2.0, 2.0);
+ p.translate(100, 200);
+
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ p.drawStaticText(QPointF(11, 12), text);
+ }
+
+#if defined(DEBUG_SAVE_IMAGE)
+ imageDrawText.save("rotatedScaledAndPainter_imageDrawText.png");
+ imageDrawStaticText.save("rotatedScaledAndPainter_imageDrawStaticText.png");
+#endif
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+void tst_QStaticText::transformationChanged()
+{
+ QPixmap imageDrawText(1000, 1000);
+ imageDrawText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawText);
+ p.rotate(33.0);
+ p.scale(0.5, 0.7);
+
+ p.drawText(0, 0, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+
+ p.scale(7.0, 5.0);
+ p.drawText(0, 0, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ }
+
+ QPixmap imageDrawStaticText(1000, 1000);
+ imageDrawStaticText.fill(Qt::white);
+ {
+ QPainter p(&imageDrawStaticText);
+ p.rotate(33.0);
+ p.scale(0.5, 0.7);
+
+ QStaticText text("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
+ p.drawStaticText(QPointF(0, 0), text);
+
+ p.scale(7.0, 5.0);
+ p.drawStaticText(QPointF(0, 0), text);
+ }
+
+#if defined(DEBUG_SAVE_IMAGE)
+ imageDrawText.save("transformationChanged_imageDrawText.png");
+ imageDrawStaticText.save("transformationChanged_imageDrawStaticText.png");
+#endif
+
+ QCOMPARE(imageDrawStaticText, imageDrawText);
+}
+
+QTEST_MAIN(tst_QStaticText)
+#include "tst_qstatictext.moc"
generated by cgit v0.12 at 2025-01-22 20:15:59 (GMT)