Long live Qt 4.5!

3 files changed, 598 insertions, 0 deletions

diff --git a/tests/auto/qfont/.gitignore b/tests/auto/qfont/.gitignore
new file mode 100644
index 0000000..61aa3df
--- /dev/null
+++ b/tests/auto/qfont/.gitignore
@@ -0,0 +1 @@
+tst_qfont
diff --git a/tests/auto/qfont/qfont.pro b/tests/auto/qfont/qfont.pro
new file mode 100644
index 0000000..b071d88
--- /dev/null
+++ b/tests/auto/qfont/qfont.pro
@@ -0,0 +1,4 @@
+load(qttest_p4)
+SOURCES  += tst_qfont.cpp
+
+
diff --git a/tests/auto/qfont/tst_qfont.cpp b/tests/auto/qfont/tst_qfont.cpp
new file mode 100644
index 0000000..58e837e
--- /dev/null
+++ b/tests/auto/qfont/tst_qfont.cpp
@@ -0,0 +1,593 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+
+#include <qfont.h>
+#include <qfontdatabase.h>
+#include <qfontinfo.h>
+#include <qstringlist.h>
+#include <qapplication.h>
+#include <qwidget.h>
+#include <qlist.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QFont : public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QFont();
+    virtual ~tst_QFont();
+
+public slots:
+    void init();
+    void cleanup();
+private slots:
+    void getSetCheck();
+    void exactMatch();
+    void compare();
+    void resolve();
+    void resetFont();
+    void isCopyOf();
+    void setFontRaw();
+    void italicOblique();
+    void insertAndRemoveSubstitutions();
+    void serializeSpacing();
+};
+
+// Testing get/set functions
+void tst_QFont::getSetCheck()
+{
+    QFont obj1;
+    // Style QFont::style()
+    // void QFont::setStyle(Style)
+    obj1.setStyle(QFont::Style(QFont::StyleNormal));
+    QCOMPARE(QFont::Style(QFont::StyleNormal), obj1.style());
+    obj1.setStyle(QFont::Style(QFont::StyleItalic));
+    QCOMPARE(QFont::Style(QFont::StyleItalic), obj1.style());
+    obj1.setStyle(QFont::Style(QFont::StyleOblique));
+    QCOMPARE(QFont::Style(QFont::StyleOblique), obj1.style());
+
+    // StyleStrategy QFont::styleStrategy()
+    // void QFont::setStyleStrategy(StyleStrategy)
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferDefault));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferDefault), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferBitmap));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferBitmap), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferDevice));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferDevice), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferOutline));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferOutline), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::ForceOutline));
+    QCOMPARE(QFont::StyleStrategy(QFont::ForceOutline), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferMatch));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferMatch), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferQuality));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferQuality), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferAntialias));
+    QCOMPARE(QFont::StyleStrategy(QFont::PreferAntialias), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::NoAntialias));
+    QCOMPARE(QFont::StyleStrategy(QFont::NoAntialias), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::OpenGLCompatible));
+    QCOMPARE(QFont::StyleStrategy(QFont::OpenGLCompatible), obj1.styleStrategy());
+}
+
+tst_QFont::tst_QFont()
+{
+}
+
+tst_QFont::~tst_QFont()
+{
+
+}
+
+void tst_QFont::init()
+{
+// TODO: Add initialization code here.
+// This will be executed immediately before each test is run.
+}
+
+void tst_QFont::cleanup()
+{
+// TODO: Add cleanup code here.
+// This will be executed immediately after each test is run.
+}
+
+void tst_QFont::exactMatch()
+{
+    QFont font;
+
+    // Check if a non-existing font hasn't an exact match
+    font = QFont( "BogusFont", 33 );
+    QVERIFY( !font.exactMatch() );
+
+#ifdef Q_WS_WIN
+    QSKIP("Exact matching on windows misses a lot because of the sample chars", SkipAll);
+    return;
+#endif
+
+    QSKIP("This test is bogus on Unix with support for font aliases in fontconfig", SkipAll);
+    return;
+
+    QFontDatabase fdb;
+
+    QList<QFontDatabase::WritingSystem> systems = fdb.writingSystems();
+    for (int system = 0; system < systems.count(); ++system) {
+        QStringList families = fdb.families(systems[system]);
+        if (families.isEmpty())
+            return;
+
+        QStringList::ConstIterator f_it, f_end = families.end();
+        for (f_it = families.begin(); f_it != f_end; ++f_it) {
+            const QString &family = *f_it;
+            if (family.contains('['))
+                continue;
+
+            QStringList styles = fdb.styles(family);
+            QVERIFY(!styles.isEmpty());
+            QStringList::ConstIterator s_it, s_end = styles.end();
+            for (s_it = styles.begin(); s_it != s_end; ++s_it) {
+                const QString &style = *s_it;
+
+                if (fdb.isSmoothlyScalable(family, style)) {
+                    // smoothly scalable font... don't need to load every pointsize
+                    font = fdb.font(family, style, 12);
+                    QFontInfo fontinfo(font);
+
+                    if (! fontinfo.exactMatch()) {
+                        // Unfortunately, this can fail, since
+                        // QFontDatabase does not fill in all font
+                        // properties.  Check to make sure that the
+                        // test didn't fail for obvious reasons
+
+                        if (fontinfo.family().isEmpty()
+                                && fontinfo.pointSize() == 0) {
+                            // this is a box rendering engine... this can happen from
+                            // time to time, especially on X11 with iso10646-1 or
+                            // unknown font encodings
+                            continue;
+                        }
+
+#ifdef Q_WS_WIN32
+                        if (font.family().startsWith("MS ") || fontinfo.family().startsWith("MS ")) {
+                            /* qDebug("Family matching skipped for MS-Alias font: %s, fontinfo: %s",
+                               font.family().latin1(), fontinfo.family().latin1());
+                               */
+                        } else
+#endif
+                        {
+                            if (!(font.family() == fontinfo.family()
+                                        || fontinfo.family().contains(font.family())
+                                        || fontinfo.family().isEmpty())) {
+                                qDebug("Test about to fail for font: %s, fontinfo: %s",
+                                        font.family().toLatin1().constData(),
+                                        fontinfo.family().toLatin1().constData());
+                            }
+                            QVERIFY(font.family() == fontinfo.family()
+                                    || fontinfo.family().contains(font.family())
+                                    || fontinfo.family().isEmpty());
+                        }
+                        if (font.pointSize() != -1) {
+                            QVERIFY(font.pointSize() == fontinfo.pointSize());
+                        } else {
+                            QVERIFY(font.pixelSize() == fontinfo.pixelSize());
+                        }
+                        QVERIFY(font.italic() == fontinfo.italic());
+                        if (font.weight() != fontinfo.weight()) {
+                            qDebug("font is %s", font.toString().toLatin1().constData());
+                        }
+                        QVERIFY(font.weight() == fontinfo.weight());
+                    } else {
+                        font.setFixedPitch(!fontinfo.fixedPitch());
+                        QFontInfo fontinfo1(font);
+                        QVERIFY( !fontinfo1.exactMatch() );
+
+                        font.setFixedPitch(fontinfo.fixedPitch());
+                        QFontInfo fontinfo2(font);
+                        QVERIFY( fontinfo2.exactMatch() );
+                    }
+                }
+#if 0
+                // ############## can only work if we have float point sizes in QFD
+                else {
+                    QList<int> sizes = fdb.pointSizes(family, style);
+                    QVERIFY(!sizes.isEmpty());
+                    QList<int>::ConstIterator z_it, z_end = sizes.end();
+                    for (z_it = sizes.begin(); z_it != z_end; ++z_it) {
+                        const int size = *z_it;
+
+                        // Initialize the font, and check if it is an exact match
+                        font = fdb.font(family, style, size);
+                        QFontInfo fontinfo(font, (QFont::Script) script);
+
+                        if (! fontinfo.exactMatch()) {
+                            // Unfortunately, this can fail, since
+                            // QFontDatabase does not fill in all font
+                            // properties.  Check to make sure that the
+                            // test didn't fail for obvious reasons
+
+                            if (fontinfo.family().isEmpty()
+                                    && fontinfo.pointSize() == 0) {
+                                // this is a box rendering engine... this can happen from
+                                // time to time, especially on X11 with iso10646-1 or
+                                // unknown font encodings
+                                continue;
+                            }
+
+                            // no need to skip MS-fonts here it seems
+                            if (!(font.family() == fontinfo.family()
+                                        || fontinfo.family().contains(font.family())
+                                        || fontinfo.family().isEmpty())) {
+                                qDebug("Test about to fail for font: %s, fontinfo: %s",
+                                        font.family().latin1(), fontinfo.family().latin1());
+                            }
+                            QVERIFY(font.family() == fontinfo.family()
+                                    || fontinfo.family().contains(font.family())
+                                    || fontinfo.family().isEmpty());
+                            if (font.pointSize() != -1) {
+                                QVERIFY(font.pointSize() == fontinfo.pointSize());
+                            } else {
+                                QVERIFY(font.pixelSize() == fontinfo.pixelSize());
+                            }
+                            QVERIFY(font.italic() == fontinfo.italic());
+                            QVERIFY(font.weight() == fontinfo.weight());
+                        } else {
+                            font.setFixedPitch(!fontinfo.fixedPitch());
+                            QFontInfo fontinfo1(font, (QFont::Script) script);
+                            QVERIFY( !fontinfo1.exactMatch() );
+
+                            font.setFixedPitch(fontinfo.fixedPitch());
+                            QFontInfo fontinfo2(font, (QFont::Script) script);
+                            QVERIFY( fontinfo2.exactMatch() );
+                        }
+                    }
+                }
+#endif
+            }
+        }
+    }
+}
+
+void tst_QFont::italicOblique()
+{
+    QFontDatabase fdb;
+
+    QStringList families = fdb.families();
+    if (families.isEmpty())
+        return;
+
+    QStringList::ConstIterator f_it, f_end = families.end();
+    for (f_it = families.begin(); f_it != f_end; ++f_it) {
+
+	QString family = *f_it;
+	QStringList styles = fdb.styles(family);
+	QVERIFY(!styles.isEmpty());
+	QStringList::ConstIterator s_it, s_end = styles.end();
+	for (s_it = styles.begin(); s_it != s_end; ++s_it) {
+	    QString style = *s_it;
+
+	    if (fdb.isSmoothlyScalable(family, style)) {
+		if (style.contains("Oblique")) {
+		    style.replace("Oblique", "Italic");
+		} else if (style.contains("Italic")) {
+		    style.replace("Italic", "Oblique");
+		} else {
+		    continue;
+		}
+		QFont f = fdb.font(family, style, 12);
+		QVERIFY(f.italic());
+	    }
+	}
+    }
+}
+
+void tst_QFont::compare()
+{
+    QFont font;
+    {
+	QFont font2 = font;
+	font2.setPointSize( 24 );
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+    }
+    {
+	QFont font2 = font;
+	font2.setPixelSize( 24 );
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+    }
+
+    font.setPointSize(12);
+    font.setItalic(false);
+    font.setWeight(QFont::Normal);
+    font.setUnderline(false);
+    font.setStrikeOut(false);
+    font.setOverline(false);
+    {
+	QFont font2 = font;
+	font2.setPointSize( 24 );
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+    }
+    {
+	QFont font2 = font;
+	font2.setPixelSize( 24 );
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+    }
+    {
+	QFont font2 = font;
+
+	font2.setItalic(true);
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+	font2.setItalic(false);
+	QVERIFY( font == font2 );
+    QVERIFY(!(font < font2));
+
+	font2.setWeight(QFont::Bold);
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+	font2.setWeight(QFont::Normal);
+	QVERIFY( font == font2 );
+    QVERIFY(!(font < font2));
+
+	font.setUnderline(true);
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+	font.setUnderline(false);
+	QVERIFY( font == font2 );
+    QVERIFY(!(font < font2));
+
+	font.setStrikeOut(true);
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+	font.setStrikeOut(false);
+	QVERIFY( font == font2 );
+    QVERIFY(!(font < font2));
+
+	font.setOverline(true);
+	QVERIFY( font != font2 );
+    QCOMPARE(font < font2,!(font2 < font));
+	font.setOverline(false);
+	QVERIFY( font == font2 );
+    QVERIFY(!(font < font2));
+    }
+
+#if defined(Q_WS_X11)
+    {
+	QFont font1, font2;
+	font1.setRawName("-Adobe-Helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1");
+	font2.setRawName("-Adobe-Helvetica-medium-r-normal--24-240-75-75-p-130-iso8859-1");
+	QVERIFY(font1 != font2);
+    }
+#endif
+}
+
+void tst_QFont::resolve()
+{
+    QFont font;
+    font.setPointSize(font.pointSize() * 2);
+    font.setItalic(false);
+    font.setWeight(QFont::Normal);
+    font.setUnderline(false);
+    font.setStrikeOut(false);
+    font.setOverline(false);
+    font.setStretch(QFont::Unstretched);
+
+    QFont font1;
+    font1.setWeight(QFont::Bold);
+    QFont font2 = font1.resolve(font);
+
+    QVERIFY(font2.weight() == font1.weight());
+
+    QVERIFY(font2.pointSize() == font.pointSize());
+    QVERIFY(font2.italic() == font.italic());
+    QVERIFY(font2.underline() == font.underline());
+    QVERIFY(font2.overline() == font.overline());
+    QVERIFY(font2.strikeOut() == font.strikeOut());
+    QVERIFY(font2.stretch() == font.stretch());
+
+    QFont font3;
+    font3.setStretch(QFont::UltraCondensed);
+    QFont font4 = font3.resolve(font1).resolve(font);
+
+    QVERIFY(font4.stretch() == font3.stretch());
+
+    QVERIFY(font4.weight() == font.weight());
+    QVERIFY(font4.pointSize() == font.pointSize());
+    QVERIFY(font4.italic() == font.italic());
+    QVERIFY(font4.underline() == font.underline());
+    QVERIFY(font4.overline() == font.overline());
+    QVERIFY(font4.strikeOut() == font.strikeOut());
+
+
+    QFont f1,f2,f3;
+    f2.setPointSize(45);
+    f3.setPointSize(55);
+
+    QFont f4 = f1.resolve(f2);
+    QCOMPARE(f4.pointSize(), 45);
+    f4 = f4.resolve(f3);
+    QCOMPARE(f4.pointSize(), 55);
+}
+
+void tst_QFont::resetFont()
+{
+    QWidget parent;
+    QFont parentFont = parent.font();
+    parentFont.setPointSize(parentFont.pointSize() + 2);
+    parent.setFont(parentFont);
+
+    QWidget *child = new QWidget(&parent);
+
+    QFont childFont = child->font();
+    childFont.setBold(!childFont.bold());
+    child->setFont(childFont);
+
+    QVERIFY(parentFont.resolve() != 0);
+    QVERIFY(childFont.resolve() != 0);
+    QVERIFY(childFont != parentFont);
+
+    child->setFont(QFont()); // reset font
+
+    QVERIFY(child->font().resolve() == 0);
+    QVERIFY(child->font().pointSize() == parent.font().pointSize());
+    QVERIFY(parent.font().resolve() != 0);
+}
+
+void tst_QFont::isCopyOf()
+{
+    QFont font;
+    QVERIFY(font.isCopyOf(QApplication::font()));
+
+    QFont font2("bogusfont",  23);
+    QVERIFY(! font2.isCopyOf(QApplication::font()));
+
+    QFont font3 = font;
+    QVERIFY(font3.isCopyOf(font));
+
+    font3.setPointSize(256);
+    QVERIFY(!font3.isCopyOf(font));
+    font3.setPointSize(font.pointSize());
+    QVERIFY(!font3.isCopyOf(font));
+}
+
+void tst_QFont::setFontRaw()
+{
+#ifndef Q_WS_X11
+    QSKIP("Only tested on X11", SkipAll);
+#else
+    QFont f;
+    f.setRawName("-*-fixed-bold-r-normal--0-0-*-*-*-0-iso8859-1");
+//     qDebug("font family: %s", f.family().utf8());
+    QFontDatabase fdb;
+    QStringList families = fdb.families();
+    bool found = false;
+    for (int i = 0; i < families.size(); ++i) {
+        QString str = families.at(i);
+        if (str.contains('['))
+            str = str.left(str.indexOf('[')-1);
+        if (str.toLower() == "fixed")
+            found = true;
+    }
+    if (!found) {
+        QSKIP("Fixed font not available.", SkipSingle);
+    }
+    QCOMPARE(QFontInfo(f).family().left(5).toLower(), QString("fixed"));
+#endif
+}
+
+void tst_QFont::insertAndRemoveSubstitutions()
+{
+    QFont::removeSubstitution("BogusFontFamily");
+    // make sure it is empty before we start
+    QVERIFY(QFont::substitutes("BogusFontFamily").isEmpty());
+    QVERIFY(QFont::substitutes("bogusfontfamily").isEmpty());
+
+    // inserting Foo
+    QFont::insertSubstitution("BogusFontFamily", "Foo");
+    QCOMPARE(QFont::substitutes("BogusFontFamily").count(), 1);
+    QCOMPARE(QFont::substitutes("bogusfontfamily").count(), 1);
+
+    // inserting Bar and Baz
+    QStringList moreFonts;
+    moreFonts << "Bar" << "Baz";
+    QFont::insertSubstitutions("BogusFontFamily", moreFonts);
+#if (QT_VERSION <= 0x040102)
+    QEXPECT_FAIL("", "Uppercase/Lowercase issues fixed in 4.1.3 and beyond", Abort);
+#endif
+    QCOMPARE(QFont::substitutes("BogusFontFamily").count(), 3);
+    QCOMPARE(QFont::substitutes("bogusfontfamily").count(), 3);
+
+    QFont::removeSubstitution("BogusFontFamily");
+    // make sure it is empty again
+    QVERIFY(QFont::substitutes("BogusFontFamily").isEmpty());
+    QVERIFY(QFont::substitutes("bogusfontfamily").isEmpty());
+}
+
+
+static QFont copyFont(const QFont &font1) // copy using a QDataStream
+{
+    QBuffer buffer;
+    buffer.open(QIODevice::WriteOnly);
+    QDataStream ds(&buffer);
+    ds << font1;
+    buffer.close();
+
+    buffer.open(QIODevice::ReadOnly);
+    QFont font2;
+    ds >> font2;
+    return font2;
+}
+
+void tst_QFont::serializeSpacing()
+{
+    QFont font;
+    QCOMPARE(font.letterSpacing(), 0.);
+    QCOMPARE(font.wordSpacing(), 0.);
+
+    font.setLetterSpacing(QFont::AbsoluteSpacing, 105);
+    QCOMPARE(font.letterSpacing(), 105.);
+    QCOMPARE(font.letterSpacingType(), QFont::AbsoluteSpacing);
+    QCOMPARE(font.wordSpacing(), 0.);
+    QFont font2 = copyFont(font);
+    QCOMPARE(font2.letterSpacing(), 105.);
+    QCOMPARE(font2.letterSpacingType(), QFont::AbsoluteSpacing);
+    QCOMPARE(font2.wordSpacing(), 0.);
+
+    font.setWordSpacing(50.0);
+    QCOMPARE(font.letterSpacing(), 105.);
+    QCOMPARE(font.wordSpacing(), 50.);
+
+    QFont font3 = copyFont(font);
+    QCOMPARE(font3.letterSpacing(), 105.);
+    QCOMPARE(font3.letterSpacingType(), QFont::AbsoluteSpacing);
+    QCOMPARE(font3.wordSpacing(), 50.);
+}
+
+QTEST_MAIN(tst_QFont)
+#include "tst_qfont.moc"