Move tst_qprinter.cpp to QtPrintSupport

QPrinter and QPrinterInfo belong to QtPrintSupport.

Change-Id: I0c146e0c717be365e752c1eaf7dbe6765fb72da2
Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>

7 files changed, 1442 insertions, 0 deletions

diff --git a/tests/auto/printsupport/kernel/kernel.pro b/tests/auto/printsupport/kernel/kernel.pro
new file mode 100644
index 0000000000..6f5802bf3e
--- /dev/null
+++ b/tests/auto/printsupport/kernel/kernel.pro
@@ -0,0 +1,4 @@
+TEMPLATE=subdirs
+SUBDIRS=\
+    qprinter \
+    qprinterinfo \
diff --git a/tests/auto/printsupport/kernel/qprinter/.gitignore b/tests/auto/printsupport/kernel/qprinter/.gitignore
new file mode 100644
index 0000000000..85de0e9675
--- /dev/null
+++ b/tests/auto/printsupport/kernel/qprinter/.gitignore
@@ -0,0 +1,4 @@
+tqpluginloader/st_qprinter
+silly
+test.pdf
+
diff --git a/tests/auto/printsupport/kernel/qprinter/qprinter.pro b/tests/auto/printsupport/kernel/qprinter/qprinter.pro
new file mode 100644
index 0000000000..7543e91f8c
--- /dev/null
+++ b/tests/auto/printsupport/kernel/qprinter/qprinter.pro
@@ -0,0 +1,7 @@
+CONFIG += testcase
+TARGET = tst_qprinter
+QT += printsupport widgets testlib
+SOURCES  += tst_qprinter.cpp
+
+mac*:CONFIG+=insignificant_test
+win32:CONFIG += insignificant_test # QTBUG-24191
diff --git a/tests/auto/printsupport/kernel/qprinter/tst_qprinter.cpp b/tests/auto/printsupport/kernel/qprinter/tst_qprinter.cpp
new file mode 100644
index 0000000000..3460ad702b
--- /dev/null
+++ b/tests/auto/printsupport/kernel/qprinter/tst_qprinter.cpp
@@ -0,0 +1,1023 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+
+#include <qprinter.h>
+#include <qpagesetupdialog.h>
+#include <qpainter.h>
+#include <qprintdialog.h>
+#include <qprinterinfo.h>
+#include <qvariant.h>
+#include <qpainter.h>
+#include <qprintengine.h>
+
+#include <math.h>
+
+#ifdef Q_OS_WIN
+#include <windows.h>
+#endif
+
+Q_DECLARE_METATYPE(QRect)
+
+QT_FORWARD_DECLARE_CLASS(QPrinter)
+
+// Helper class to make sure temp files are cleaned up after test complete
+class TempFileCleanup
+{
+public:
+    TempFileCleanup(const QString &file)
+        : m_file(file)
+    {
+    }
+
+    ~TempFileCleanup()
+    {
+        QFile::remove(m_file);
+    }
+private:
+    QString m_file;
+};
+
+class tst_QPrinter : public QObject
+{
+    Q_OBJECT
+
+#ifdef QT_NO_PRINTER
+public slots:
+    void initTestCase();
+#else
+private slots:
+    void getSetCheck();
+// Add your testfunctions and testdata create functions here
+    void testPageSize();
+    void testPageRectAndPaperRect();
+    void testPageRectAndPaperRect_data();
+    void testSetOptions();
+    void testMargins_data();
+    void testMargins();
+    void testNonExistentPrinter();
+    void testPageSetupDialog();
+    void testMulitpleSets_data();
+    void testMulitpleSets();
+    void testPageMargins_data();
+    void testPageMargins();
+    void changingOutputFormat();
+    void outputFormatFromSuffix();
+    void setGetPaperSize();
+    void valuePreservation();
+    void errorReporting();
+    void testCustomPageSizes();
+#if !defined(QT_NO_COMPLETER) && !defined(QT_NO_FILEDIALOG)
+    void printDialogCompleter();
+#endif
+
+    void testCopyCount();
+    void testCurrentPage();
+
+    void taskQTBUG4497_reusePrinterOnDifferentFiles();
+    void testPdfTitle();
+#endif
+};
+
+#ifdef QT_NO_PRINTER
+void tst_QPrinter::initTestCase()
+{
+    QSKIP("This test requires printing support");
+}
+
+#else
+
+// Testing get/set functions
+void tst_QPrinter::getSetCheck()
+{
+    QPrinter obj1;
+    // OutputFormat QPrinter::outputFormat()
+    // void QPrinter::setOutputFormat(OutputFormat)
+    obj1.setOutputFormat(QPrinter::OutputFormat(QPrinter::PdfFormat));
+    QCOMPARE(QPrinter::OutputFormat(QPrinter::PdfFormat), obj1.outputFormat());
+
+    // bool QPrinter::collateCopies()
+    // void QPrinter::setCollateCopies(bool)
+    obj1.setCollateCopies(false);
+    QCOMPARE(false, obj1.collateCopies());
+    obj1.setCollateCopies(true);
+    QCOMPARE(true, obj1.collateCopies());
+
+    obj1.setColorMode(QPrinter::GrayScale);
+    QCOMPARE(obj1.colorMode(), QPrinter::GrayScale);
+    obj1.setColorMode(QPrinter::Color);
+    QCOMPARE(obj1.colorMode(), QPrinter::Color);
+
+    obj1.setCreator(QString::fromLatin1("RandomQtUser"));
+    QCOMPARE(obj1.creator(), QString::fromLatin1("RandomQtUser"));
+
+    obj1.setDocName(QString::fromLatin1("RandomQtDocument"));
+    QCOMPARE(obj1.docName(), QString::fromLatin1("RandomQtDocument"));
+
+    obj1.setDoubleSidedPrinting(true);
+    QCOMPARE(obj1.doubleSidedPrinting(), true);
+    obj1.setDoubleSidedPrinting(false);
+    QCOMPARE(obj1.doubleSidedPrinting(), false);
+
+    obj1.setFromTo(1, 4);
+    QCOMPARE(obj1.fromPage(), 1);
+    QCOMPARE(obj1.toPage(), 4);
+
+    obj1.setFullPage(true);
+    QCOMPARE(obj1.fullPage(), true);
+    obj1.setFullPage(false);
+    QCOMPARE(obj1.fullPage(), false);
+
+    obj1.setOrientation(QPrinter::Landscape);
+    QCOMPARE(obj1.orientation(), QPrinter::Landscape);
+    obj1.setOrientation(QPrinter::Portrait);
+    QCOMPARE(obj1.orientation(), QPrinter::Portrait);
+
+    obj1.setOutputFileName(QString::fromLatin1("RandomQtName"));
+    QCOMPARE(obj1.outputFileName(), QString::fromLatin1("RandomQtName"));
+
+    obj1.setPageOrder(QPrinter::FirstPageFirst);
+    QCOMPARE(obj1.pageOrder(), QPrinter::FirstPageFirst);
+    obj1.setPageOrder(QPrinter::LastPageFirst);
+    QCOMPARE(obj1.pageOrder(), QPrinter::LastPageFirst);
+
+    obj1.setPaperSource(QPrinter::Cassette);
+    QCOMPARE(obj1.paperSource(), QPrinter::Cassette);
+    obj1.setPaperSource(QPrinter::Middle);
+    QCOMPARE(obj1.paperSource(), QPrinter::Middle);
+
+#ifdef Q_OS_UNIX
+    obj1.setPrintProgram(QString::fromLatin1("/bin/true"));
+    QCOMPARE(obj1.printProgram(), QString::fromLatin1("/bin/true"));
+
+    obj1.setPrinterSelectionOption(QString::fromLatin1("--option"));
+    QCOMPARE(obj1.printerSelectionOption(), QString::fromLatin1("--option"));
+#endif
+
+    obj1.setPrinterName(QString::fromLatin1("myPrinter"));
+    QCOMPARE(obj1.printerName(), QString::fromLatin1("myPrinter"));
+
+    // bool QPrinter::fontEmbeddingEnabled()
+    // void QPrinter::setFontEmbeddingEnabled(bool)
+    obj1.setFontEmbeddingEnabled(false);
+    QCOMPARE(false, obj1.fontEmbeddingEnabled());
+    obj1.setFontEmbeddingEnabled(true);
+    QCOMPARE(true, obj1.fontEmbeddingEnabled());
+
+    // PageSize QPrinter::pageSize()
+    // void QPrinter::setPageSize(PageSize)
+    obj1.setPageSize(QPrinter::PageSize(QPrinter::A4));
+    QCOMPARE(QPrinter::PageSize(QPrinter::A4), obj1.pageSize());
+    obj1.setPageSize(QPrinter::PageSize(QPrinter::Letter));
+    QCOMPARE(QPrinter::PageSize(QPrinter::Letter), obj1.pageSize());
+    obj1.setPageSize(QPrinter::PageSize(QPrinter::Legal));
+    QCOMPARE(QPrinter::PageSize(QPrinter::Legal), obj1.pageSize());
+
+    // PrintRange QPrinter::printRange()
+    // void QPrinter::setPrintRange(PrintRange)
+    obj1.setPrintRange(QPrinter::PrintRange(QPrinter::AllPages));
+    QCOMPARE(QPrinter::PrintRange(QPrinter::AllPages), obj1.printRange());
+    obj1.setPrintRange(QPrinter::PrintRange(QPrinter::Selection));
+    QCOMPARE(QPrinter::PrintRange(QPrinter::Selection), obj1.printRange());
+    obj1.setPrintRange(QPrinter::PrintRange(QPrinter::PageRange));
+    QCOMPARE(QPrinter::PrintRange(QPrinter::PageRange), obj1.printRange());
+}
+
+#define MYCOMPARE(a, b) QCOMPARE(QVariant((int)a), QVariant((int)b))
+
+void tst_QPrinter::testPageSetupDialog()
+{
+    // Make sure this doesn't crash at least
+    {
+        QPrinter printer;
+        QPageSetupDialog dialog(&printer);
+    }
+}
+
+void tst_QPrinter::testPageSize()
+{
+#if 1
+    QSKIP("QPrinter::winPageSize(): Windows only and currently not implemented / QTBUG-22927");
+#else
+    QPrinter prn;
+
+    prn.setPageSize(QPrinter::Letter);
+    MYCOMPARE(prn.pageSize(), QPrinter::Letter);
+    MYCOMPARE(prn.winPageSize(), DMPAPER_LETTER);
+
+    prn.setPageSize(QPrinter::A4);
+    MYCOMPARE(prn.pageSize(), QPrinter::A4);
+    MYCOMPARE(prn.winPageSize(), DMPAPER_A4);
+
+    prn.setWinPageSize(DMPAPER_LETTER);
+    MYCOMPARE(prn.winPageSize(), DMPAPER_LETTER);
+    MYCOMPARE(prn.pageSize(), QPrinter::Letter);
+
+    prn.setWinPageSize(DMPAPER_A4);
+    MYCOMPARE(prn.winPageSize(), DMPAPER_A4);
+    MYCOMPARE(prn.pageSize(), QPrinter::A4);
+#endif
+}
+
+void tst_QPrinter::testPageRectAndPaperRect_data()
+{
+    QTest::addColumn<int>("orientation");
+    QTest::addColumn<bool>("withPainter");
+    QTest::addColumn<int>("resolution");
+    QTest::addColumn<bool>("doPaperRect");
+
+    // paperrect
+    QTest::newRow("paperRect0") << int(QPrinter::Portrait) << true << 300 << true;
+    QTest::newRow("paperRect1") << int(QPrinter::Portrait) << false << 300 << true;
+    QTest::newRow("paperRect2") << int(QPrinter::Landscape) << true << 300 << true;
+    QTest::newRow("paperRect3") << int(QPrinter::Landscape) << false << 300 << true;
+    QTest::newRow("paperRect4") << int(QPrinter::Portrait) << true << 600 << true;
+    QTest::newRow("paperRect5") << int(QPrinter::Portrait) << false << 600 << true;
+    QTest::newRow("paperRect6") << int(QPrinter::Landscape) << true << 600 << true;
+    QTest::newRow("paperRect7") << int(QPrinter::Landscape) << false << 600 << true;
+    QTest::newRow("paperRect8") << int(QPrinter::Portrait) << true << 1200 << true;
+    QTest::newRow("paperRect9") << int(QPrinter::Portrait) << false << 1200 << true;
+    QTest::newRow("paperRect10") << int(QPrinter::Landscape) << true << 1200 << true;
+    QTest::newRow("paperRect11") << int(QPrinter::Landscape) << false << 1200 << true;
+
+    // page rect
+    QTest::newRow("pageRect0") << int(QPrinter::Portrait) << true << 300 << false;
+    QTest::newRow("pageRect1") << int(QPrinter::Portrait) << false << 300 << false;
+    QTest::newRow("pageRect2") << int(QPrinter::Landscape) << true << 300 << false;
+    QTest::newRow("pageRect3") << int(QPrinter::Landscape) << false << 300 << false;
+    QTest::newRow("pageRect4") << int(QPrinter::Portrait) << true << 600 << false;
+    QTest::newRow("pageRect5") << int(QPrinter::Portrait) << false << 600 << false;
+    QTest::newRow("pageRect6") << int(QPrinter::Landscape) << true << 600 << false;
+    QTest::newRow("pageRect7") << int(QPrinter::Landscape) << false << 600 << false;
+    QTest::newRow("pageRect8") << int(QPrinter::Portrait) << true << 1200 << false;
+    QTest::newRow("pageRect9") << int(QPrinter::Portrait) << false << 1200 << false;
+    QTest::newRow("pageRect10") << int(QPrinter::Landscape) << true << 1200 << false;
+    QTest::newRow("pageRect11") << int(QPrinter::Landscape) << false << 1200 << false;
+}
+
+void tst_QPrinter::testPageRectAndPaperRect()
+{
+    QFETCH(bool,  withPainter);
+    QFETCH(int,  orientation);
+    QFETCH(int, resolution);
+    QFETCH(bool, doPaperRect);
+
+    QPainter *painter = 0;
+    QPrinter printer(QPrinter::HighResolution);
+    printer.setOrientation(QPrinter::Orientation(orientation));
+    printer.setOutputFileName("silly");
+    TempFileCleanup tmpFile("silly");
+
+    QRect pageRect = doPaperRect ? printer.paperRect() : printer.pageRect();
+    float inchesX = float(pageRect.width()) / float(printer.resolution());
+    float inchesY = float(pageRect.height()) / float(printer.resolution());
+    printer.setResolution(resolution);
+    if (withPainter)
+        painter = new QPainter(&printer);
+
+    QRect otherRect = doPaperRect ? printer.paperRect() : printer.pageRect();
+    float otherInchesX = float(otherRect.width()) / float(printer.resolution());
+    float otherInchesY = float(otherRect.height()) / float(printer.resolution());
+    if (painter != 0)
+        delete painter;
+
+    QVERIFY(qAbs(otherInchesX - inchesX) < 0.01);
+    QVERIFY(qAbs(otherInchesY - inchesY) < 0.01);
+
+    QVERIFY(printer.orientation() == QPrinter::Portrait || pageRect.width() > pageRect.height());
+    QVERIFY(printer.orientation() != QPrinter::Portrait || pageRect.width() < pageRect.height());
+}
+
+void tst_QPrinter::testSetOptions()
+{
+    QPrinter prn;
+    QPrintDialog dlg(&prn);
+
+    // Verify default values
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintToFile), true);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintSelection), false);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintPageRange), true);
+
+    dlg.setEnabledOptions(QAbstractPrintDialog::PrintPageRange);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintToFile), false);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintSelection), false);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintPageRange), true);
+
+    dlg.setEnabledOptions((QAbstractPrintDialog::PrintDialogOptions(QAbstractPrintDialog::PrintSelection
+                                                                    | QAbstractPrintDialog::PrintPageRange)));
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintToFile), false);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintSelection), true);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintPageRange), true);
+
+    dlg.setEnabledOptions(QAbstractPrintDialog::PrintSelection);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintToFile), false);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintSelection), true);
+    MYCOMPARE(dlg.isOptionEnabled(QAbstractPrintDialog::PrintPageRange), false);
+}
+
+void tst_QPrinter::testMargins_data()
+{
+    QTest::addColumn<int>("orientation");
+    QTest::addColumn<bool>("fullpage");
+    QTest::addColumn<int>("pagesize");
+    QTest::addColumn<int>("width");
+    QTest::addColumn<int>("height");
+    QTest::addColumn<bool>("withPainter");
+
+    QTest::newRow("data0") << int(QPrinter::Portrait) << true << int(QPrinter::A4) << 210 << 297 << false;
+    QTest::newRow("data1") << int(QPrinter::Landscape) << true << int(QPrinter::A4) << 297 << 210 << false;
+    QTest::newRow("data2") << int(QPrinter::Landscape) << false << int(QPrinter::A4) << 297 << 210 << false;
+    QTest::newRow("data3") << int(QPrinter::Portrait) << false << int(QPrinter::A4) << 210 << 297 << false;
+    QTest::newRow("data4") << int(QPrinter::Portrait) << true << int(QPrinter::A4) << 210 << 297 << true;
+    QTest::newRow("data5") << int(QPrinter::Landscape) << true << int(QPrinter::A4) << 297 << 210 << true;
+    QTest::newRow("data6") << int(QPrinter::Landscape) << false << int(QPrinter::A4) << 297 << 210 << true;
+    QTest::newRow("data7") << int(QPrinter::Portrait) << false << int(QPrinter::A4) << 210 << 297 << true;
+}
+
+void tst_QPrinter::testMargins()
+{
+    QFETCH(bool,  withPainter);
+    QFETCH(int,  orientation);
+    QFETCH(int,  pagesize);
+    QFETCH(int,  width);
+    QFETCH(int,  height);
+    QFETCH(bool, fullpage);
+    Q_UNUSED(width);
+    Q_UNUSED(height);
+    QPrinter printer;
+    QPainter *painter = 0;
+    printer.setOutputFileName("silly");
+    printer.setOrientation((QPrinter::Orientation)orientation);
+    printer.setFullPage(fullpage);
+    printer.setPageSize((QPrinter::PageSize)pagesize);
+    if (withPainter)
+        painter = new QPainter(&printer);
+
+    if (painter)
+        delete painter;
+    QFile::remove("silly");
+}
+
+void tst_QPrinter::testNonExistentPrinter()
+{
+#ifndef Q_OS_WIN
+    QSKIP("QPrinter::testNonExistentPrinter() is not relevant for this platform");
+#else
+    QPrinter printer;
+    QPainter painter;
+
+    // Make sure it doesn't crash on setting or getting properties
+    printer.setPrinterName("some non existing printer");
+    printer.setPageSize(QPrinter::A4);
+    printer.setOrientation(QPrinter::Portrait);
+    printer.setFullPage(true);
+    printer.pageSize();
+    printer.orientation();
+    printer.fullPage();
+    printer.setCopyCount(1);
+    printer.printerName();
+
+    // nor metrics
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmWidth), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmHeight), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmWidthMM), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmHeightMM), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmNumColors), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmDepth), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmDpiX), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmDpiY), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmPhysicalDpiX), 0);
+    QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmPhysicalDpiY), 0);
+
+    QVERIFY(!painter.begin(&printer));
+#endif
+}
+
+void tst_QPrinter::testMulitpleSets_data()
+{
+    QTest::addColumn<int>("resolution");
+    QTest::addColumn<int>("pageSize");
+    QTest::addColumn<int>("widthMMAfter");
+    QTest::addColumn<int>("heightMMAfter");
+
+
+    QTest::newRow("lowRes") << int(QPrinter::ScreenResolution) << int(QPrinter::A4) << 210 << 297;
+    QTest::newRow("lowResLetter") << int(QPrinter::ScreenResolution) << int(QPrinter::Letter) << 216 << 279;
+    QTest::newRow("lowResA5") << int(QPrinter::ScreenResolution) << int(QPrinter::A5) << 148 << 210;
+    QTest::newRow("midRes") << int(QPrinter::PrinterResolution) << int(QPrinter::A4) << 210 << 297;
+    QTest::newRow("midResLetter") << int(QPrinter::PrinterResolution) << int(QPrinter::Letter) << 216 << 279;
+    QTest::newRow("midResA5") << int(QPrinter::PrinterResolution) << int(QPrinter::A5) << 148 << 210;
+    QTest::newRow("highRes") << int(QPrinter::HighResolution) << int(QPrinter::A4) << 210 << 297;
+    QTest::newRow("highResLetter") << int(QPrinter::HighResolution) << int(QPrinter::Letter) << 216 << 279;
+    QTest::newRow("highResA5") << int(QPrinter::HighResolution) << int(QPrinter::A5) << 148 << 210;
+}
+
+static void computePageValue(const QPrinter &printer, int &retWidth, int &retHeight)
+{
+    const double Inch2MM = 25.4;
+
+    double width = double(printer.paperRect().width()) / printer.logicalDpiX() * Inch2MM;
+    double height = double(printer.paperRect().height()) / printer.logicalDpiY() * Inch2MM;
+    retWidth = qRound(width);
+    retHeight = qRound(height);
+}
+
+void tst_QPrinter::testMulitpleSets()
+{
+    // A very simple test, but Mac needs to have its format "validated" if the format is changed
+    // This takes care of that.
+    QFETCH(int, resolution);
+    QFETCH(int, pageSize);
+    QFETCH(int, widthMMAfter);
+    QFETCH(int, heightMMAfter);
+
+
+    QPrinter::PrinterMode mode = QPrinter::PrinterMode(resolution);
+    QPrinter::PageSize printerPageSize = QPrinter::PageSize(pageSize);
+    QPrinter printer(mode);
+    printer.setFullPage(true);
+
+    int paperWidth, paperHeight;
+    //const int Tolerance = 2;
+
+    computePageValue(printer, paperWidth, paperHeight);
+    printer.setPageSize(printerPageSize);
+
+    if (printer.pageSize() != printerPageSize) {
+        QSKIP("Current page size is not supported on this printer");
+        return;
+    }
+
+    QCOMPARE(printer.widthMM(), widthMMAfter);
+    QCOMPARE(printer.heightMM(), heightMMAfter);
+
+    computePageValue(printer, paperWidth, paperHeight);
+
+    QVERIFY(qAbs(paperWidth - widthMMAfter) <= 2);
+    QVERIFY(qAbs(paperHeight - heightMMAfter) <= 2);
+
+    // Set it again and see if it still works.
+    printer.setPageSize(printerPageSize);
+    QCOMPARE(printer.widthMM(), widthMMAfter);
+    QCOMPARE(printer.heightMM(), heightMMAfter);
+
+    printer.setOrientation(QPrinter::Landscape);
+    computePageValue(printer, paperWidth, paperHeight);
+    QVERIFY(qAbs(paperWidth - heightMMAfter) <= 2);
+    QVERIFY(qAbs(paperHeight - widthMMAfter) <= 2);
+}
+
+void tst_QPrinter::changingOutputFormat()
+{
+#if QT_VERSION < 0x050000
+    QPrinter p;
+    p.setOutputFormat(QPrinter::PostScriptFormat);
+    p.setPageSize(QPrinter::A8);
+    p.setOutputFormat(QPrinter::PdfFormat);
+    QCOMPARE(p.pageSize(), QPrinter::A8);
+#endif
+}
+
+void tst_QPrinter::outputFormatFromSuffix()
+{
+    if (QPrinterInfo::availablePrinters().size() == 0)
+        QSKIP("No printers available.");
+    QPrinter p;
+    QVERIFY(p.outputFormat() == QPrinter::NativeFormat);
+    p.setOutputFileName("test.pdf");
+    TempFileCleanup tmpFile("test.pdf");
+    QVERIFY(p.outputFormat() == QPrinter::PdfFormat);
+    p.setOutputFileName(QString());
+    QVERIFY(p.outputFormat() == QPrinter::NativeFormat);
+}
+
+void tst_QPrinter::setGetPaperSize()
+{
+    QPrinter p;
+    p.setOutputFormat(QPrinter::PdfFormat);
+    QSizeF size(500, 10);
+    p.setPaperSize(size, QPrinter::Millimeter);
+    QCOMPARE(p.paperSize(QPrinter::Millimeter), size);
+    QSizeF ptSize = p.paperSize(QPrinter::Point);
+    //qDebug() << ptSize;
+    QVERIFY(qAbs(ptSize.width() - size.width() * (72/25.4)) < 1E-4);
+    QVERIFY(qAbs(ptSize.height() - size.height() * (72/25.4)) < 1E-4);
+}
+
+void tst_QPrinter::testPageMargins_data()
+{
+    QTest::addColumn<qreal>("left");
+    QTest::addColumn<qreal>("top");
+    QTest::addColumn<qreal>("right");
+    QTest::addColumn<qreal>("bottom");
+    QTest::addColumn<int>("unit");
+
+    QTest::newRow("data0") << qreal(5.5) << qreal(6.5) << qreal(7.5) << qreal(8.5) << static_cast<int>(QPrinter::Millimeter);
+    QTest::newRow("data1") << qreal(5.5) << qreal(6.5) << qreal(7.5) << qreal(8.5) << static_cast<int>(QPrinter::Point);
+    QTest::newRow("data2") << qreal(5.5) << qreal(6.5) << qreal(7.5) << qreal(8.5) << static_cast<int>(QPrinter::Inch);
+    QTest::newRow("data3") << qreal(5.5) << qreal(6.5) << qreal(7.5) << qreal(8.5) << static_cast<int>(QPrinter::Pica);
+    QTest::newRow("data4") << qreal(5.5) << qreal(6.5) << qreal(7.5) << qreal(8.5) << static_cast<int>(QPrinter::Didot);
+    QTest::newRow("data5") << qreal(5.5) << qreal(6.5) << qreal(7.5) << qreal(8.5) << static_cast<int>(QPrinter::Cicero);
+}
+
+void tst_QPrinter::testPageMargins()
+{
+    QPrinter obj1;
+
+    qreal toMillimeters[6];
+    toMillimeters[QPrinter::Millimeter] = 1;
+    toMillimeters[QPrinter::Point] = 0.352777778;
+    toMillimeters[QPrinter::Inch] = 25.4;
+    toMillimeters[QPrinter::Pica] = 4.23333333;
+    toMillimeters[QPrinter::Didot] = 0.376;
+    toMillimeters[QPrinter::Cicero] = 4.51166667;
+
+    QFETCH(qreal, left);
+    QFETCH(qreal, top);
+    QFETCH(qreal, right);
+    QFETCH(qreal, bottom);
+    QFETCH(int, unit);
+
+    qreal nLeft, nTop, nRight, nBottom;
+
+    obj1.setPageMargins(left, top, right, bottom, static_cast<QPrinter::Unit>(unit));
+
+    qreal tolerance = 0.05;
+
+    obj1.getPageMargins(&nLeft, &nTop, &nRight, &nBottom, QPrinter::Millimeter);
+    QVERIFY(fabs(left*toMillimeters[unit] - nLeft*toMillimeters[QPrinter::Millimeter]) < tolerance);
+    QVERIFY(fabs(top*toMillimeters[unit] - nTop*toMillimeters[QPrinter::Millimeter]) < tolerance);
+    QVERIFY(fabs(right*toMillimeters[unit] - nRight*toMillimeters[QPrinter::Millimeter]) < tolerance);
+    QVERIFY(fabs(bottom*toMillimeters[unit] - nBottom*toMillimeters[QPrinter::Millimeter]) < tolerance);
+
+    obj1.getPageMargins(&nLeft, &nTop, &nRight, &nBottom, QPrinter::Point);
+    QVERIFY(fabs(left*toMillimeters[unit] - nLeft*toMillimeters[QPrinter::Point]) < tolerance);
+    QVERIFY(fabs(top*toMillimeters[unit] - nTop*toMillimeters[QPrinter::Point]) < tolerance);
+    QVERIFY(fabs(right*toMillimeters[unit] - nRight*toMillimeters[QPrinter::Point]) < tolerance);
+    QVERIFY(fabs(bottom*toMillimeters[unit] - nBottom*toMillimeters[QPrinter::Point]) < tolerance);
+
+    obj1.getPageMargins(&nLeft, &nTop, &nRight, &nBottom, QPrinter::Inch);
+    QVERIFY(fabs(left*toMillimeters[unit] - nLeft*toMillimeters[QPrinter::Inch]) < tolerance);
+    QVERIFY(fabs(top*toMillimeters[unit] - nTop*toMillimeters[QPrinter::Inch]) < tolerance);
+    QVERIFY(fabs(right*toMillimeters[unit] - nRight*toMillimeters[QPrinter::Inch]) < tolerance);
+    QVERIFY(fabs(bottom*toMillimeters[unit] - nBottom*toMillimeters[QPrinter::Inch]) < tolerance);
+
+    obj1.getPageMargins(&nLeft, &nTop, &nRight, &nBottom, QPrinter::Pica);
+    QVERIFY(fabs(left*toMillimeters[unit] - nLeft*toMillimeters[QPrinter::Pica]) < tolerance);
+    QVERIFY(fabs(top*toMillimeters[unit] - nTop*toMillimeters[QPrinter::Pica]) < tolerance);
+    QVERIFY(fabs(right*toMillimeters[unit] - nRight*toMillimeters[QPrinter::Pica]) < tolerance);
+    QVERIFY(fabs(bottom*toMillimeters[unit] - nBottom*toMillimeters[QPrinter::Pica]) < tolerance);
+
+    obj1.getPageMargins(&nLeft, &nTop, &nRight, &nBottom, QPrinter::Didot);
+    QVERIFY(fabs(left*toMillimeters[unit] - nLeft*toMillimeters[QPrinter::Didot]) < tolerance);
+    QVERIFY(fabs(top*toMillimeters[unit] - nTop*toMillimeters[QPrinter::Didot]) < tolerance);
+    QVERIFY(fabs(right*toMillimeters[unit] - nRight*toMillimeters[QPrinter::Didot]) < tolerance);
+    QVERIFY(fabs(bottom*toMillimeters[unit] - nBottom*toMillimeters[QPrinter::Didot]) < tolerance);
+
+    obj1.getPageMargins(&nLeft, &nTop, &nRight, &nBottom, QPrinter::Cicero);
+    QVERIFY(fabs(left*toMillimeters[unit] - nLeft*toMillimeters[QPrinter::Cicero]) < tolerance);
+    QVERIFY(fabs(top*toMillimeters[unit] - nTop*toMillimeters[QPrinter::Cicero]) < tolerance);
+    QVERIFY(fabs(right*toMillimeters[unit] - nRight*toMillimeters[QPrinter::Cicero]) < tolerance);
+    QVERIFY(fabs(bottom*toMillimeters[unit] - nBottom*toMillimeters[QPrinter::Cicero]) < tolerance);
+}
+
+void tst_QPrinter::valuePreservation()
+{
+    QPrinter::OutputFormat oldFormat = QPrinter::PdfFormat;
+    QPrinter::OutputFormat newFormat = QPrinter::NativeFormat; // TODO: Correct?
+
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        bool status = printer.collateCopies();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.collateCopies(), status);
+
+        printer.setCollateCopies(!status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.collateCopies(), !status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.collateCopies(), !status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QPrinter::ColorMode status = printer.colorMode();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.colorMode(), status);
+
+        printer.setColorMode(QPrinter::ColorMode(!status));
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.colorMode(), QPrinter::ColorMode(!status));
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.colorMode(), QPrinter::ColorMode(!status));
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QString status = printer.creator();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.creator(), status);
+
+        status = QString::fromLatin1("Mr. Test");
+        printer.setCreator(status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.creator(), status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.creator(), status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QString status = printer.docName();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.docName(), status);
+
+        status = QString::fromLatin1("Test document");
+        printer.setDocName(status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.docName(), status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.docName(), status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        bool status = printer.doubleSidedPrinting();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.doubleSidedPrinting(), status);
+
+        printer.setDoubleSidedPrinting(!status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.doubleSidedPrinting(), !status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.doubleSidedPrinting(), !status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        bool status = printer.fontEmbeddingEnabled();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.fontEmbeddingEnabled(), status);
+
+        printer.setFontEmbeddingEnabled(!status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.fontEmbeddingEnabled(), !status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.fontEmbeddingEnabled(), !status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        bool status = printer.fullPage();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.fullPage(), status);
+
+        printer.setFullPage(!status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.fullPage(), !status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.fullPage(), !status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QPrinter::Orientation status = printer.orientation();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.orientation(), status);
+
+        printer.setOrientation(QPrinter::Orientation(!status));
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.orientation(), QPrinter::Orientation(!status));
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.orientation(), QPrinter::Orientation(!status));
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QString status = printer.outputFileName();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.outputFileName(), status);
+
+        status = QString::fromLatin1("Test file");
+        printer.setOutputFileName(status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.outputFileName(), status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.outputFileName(), status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QPrinter::PageOrder status = printer.pageOrder();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.pageOrder(), status);
+
+        printer.setPageOrder(QPrinter::PageOrder(!status));
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.pageOrder(), QPrinter::PageOrder(!status));
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.pageOrder(), QPrinter::PageOrder(!status));
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QPrinter::PageSize status = printer.pageSize();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.pageSize(), status);
+
+        printer.setPageSize(QPrinter::B5);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.pageSize(), QPrinter::B5);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.pageSize(), QPrinter::B5);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QPrinter::PaperSource status = printer.paperSource();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.paperSource(), status);
+
+        printer.setPaperSource(QPrinter::Manual);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.paperSource(), QPrinter::Manual);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.paperSource(), QPrinter::Manual);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QString status = printer.printProgram();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printProgram(), status);
+
+        status = QString::fromLatin1("/usr/local/bin/lpr");
+        printer.setPrintProgram(status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.printProgram(), status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printProgram(), status);
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QPrinter::PrintRange status = printer.printRange();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printRange(), status);
+
+        printer.setPrintRange(QPrinter::PrintRange(!status));
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.printRange(), QPrinter::PrintRange(!status));
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printRange(), QPrinter::PrintRange(!status));
+    }
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QString status = printer.printerName();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printerName(), status);
+
+        status = QString::fromLatin1("SuperDuperPrinter");
+        printer.setPrinterName(status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.printerName(), status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printerName(), status);
+    }
+#ifndef Q_OS_WIN
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        QString status = printer.printerSelectionOption();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printerSelectionOption(), status);
+
+        status = QString::fromLatin1("Optional option");
+        printer.setPrinterSelectionOption(status);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.printerSelectionOption(), status);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.printerSelectionOption(), status);
+    }
+#endif
+    {
+        QPrinter printer;
+        printer.setOutputFormat(oldFormat);
+        int status = printer.resolution();
+        printer.setOutputFormat(newFormat);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.resolution(), status);
+
+        printer.setResolution(status-150);
+        printer.setOutputFormat(newFormat);
+        QCOMPARE(printer.resolution(), status-150);
+        printer.setOutputFormat(oldFormat);
+        QCOMPARE(printer.resolution(), status-150);
+    }
+}
+
+void tst_QPrinter::errorReporting()
+{
+    QPrinter p;
+    p.setOutputFormat(QPrinter::PdfFormat);
+    QCOMPARE(p.isValid(), true);
+    QPainter painter;
+#ifndef Q_WS_WIN
+    // not sure how to choose a never-writable file on windows.  But its QFile behavior anyway, so lets rely on it failing elsewhere
+    p.setOutputFileName("/foobar/nonwritable.pdf");
+    QCOMPARE(painter.begin(&p), false); // it should check the output file is writable
+#endif
+    p.setOutputFileName("test.pdf");
+    TempFileCleanup tmpFile("test.pdf");
+    QCOMPARE(painter.begin(&p), true); // it should check the output
+    QCOMPARE(p.isValid(), true);
+    painter.end();
+}
+
+void tst_QPrinter::testCustomPageSizes()
+{
+    QPrinter p;
+
+    QSizeF customSize(8.5, 11.0);
+    p.setPaperSize(customSize, QPrinter::Inch);
+
+    QSizeF paperSize = p.paperSize(QPrinter::Inch);
+    QCOMPARE(paperSize, customSize);
+
+    QPrinter p2(QPrinter::HighResolution);
+    p2.setPaperSize(customSize, QPrinter::Inch);
+    paperSize = p.paperSize(QPrinter::Inch);
+    QCOMPARE(paperSize, customSize);
+}
+
+#if !defined(QT_NO_COMPLETER) && !defined(QT_NO_FILEDIALOG)
+void tst_QPrinter::printDialogCompleter()
+{
+    QPrintDialog dialog;
+    dialog.printer()->setOutputFileName("file.pdf");
+    TempFileCleanup tmpFile("file.pdf");
+    dialog.setEnabledOptions(QAbstractPrintDialog::PrintToFile);
+    dialog.show();
+
+    QTest::qWait(100);
+
+    QTest::keyClick(&dialog, Qt::Key_Tab);
+    QTest::keyClick(&dialog, 'P');
+    // The test passes if it doesn't crash.
+}
+#endif
+
+void tst_QPrinter::testCopyCount()
+{
+    QPrinter p;
+    p.setCopyCount(15);
+    QCOMPARE(p.copyCount(), 15);
+}
+
+static void printPage(QPainter *painter)
+{
+    painter->setPen(QPen(Qt::black, 4));
+    painter->drawRect(50, 60, 70, 80);
+}
+
+void tst_QPrinter::taskQTBUG4497_reusePrinterOnDifferentFiles()
+{
+    TempFileCleanup tmpFile1("out1.ps");
+    TempFileCleanup tmpFile2("out2.ps");
+
+    QPrinter printer;
+    {
+
+        printer.setOutputFileName("out1.ps");
+        QPainter painter(&printer);
+        printPage(&painter);
+
+    }
+    {
+
+        printer.setOutputFileName("out2.ps");
+        QPainter painter(&printer);
+        printPage(&painter);
+
+    }
+    QFile file1("out1.ps");
+    QVERIFY(file1.open(QIODevice::ReadOnly));
+
+    QFile file2("out2.ps");
+    QVERIFY(file2.open(QIODevice::ReadOnly));
+
+    QEXPECT_FAIL("", "QTBUG-22562, QTBUG-22296", Abort);
+    QCOMPARE(file1.readAll(), file2.readAll());
+}
+
+void tst_QPrinter::testCurrentPage()
+{
+    QPrinter printer;
+    printer.setFromTo(1, 10);
+
+    // Test set print range
+    printer.setPrintRange(QPrinter::CurrentPage);
+    QCOMPARE(printer.printRange(), QPrinter::CurrentPage);
+    QCOMPARE(printer.fromPage(), 1);
+    QCOMPARE(printer.toPage(), 10);
+
+    QPrintDialog dialog(&printer);
+
+    // Test default Current Page option to off
+    QCOMPARE(dialog.isOptionEnabled(QPrintDialog::PrintCurrentPage), false);
+
+    // Test enable Current Page option
+    dialog.setOption(QPrintDialog::PrintCurrentPage);
+    QCOMPARE(dialog.isOptionEnabled(QPrintDialog::PrintCurrentPage), true);
+
+}
+
+void tst_QPrinter::testPdfTitle()
+{
+    // Check the document name is represented correctly in produced pdf
+    {
+        QPainter painter;
+        QPrinter printer;
+        // This string is just the UTF-8 encoding of the string: \()f &oslash; hiragana o
+        const unsigned char titleBuf[]={0x5c, 0x28, 0x29, 0x66, 0xc3, 0xb8, 0xe3, 0x81, 0x8a, 0x00};
+        const char *title = reinterpret_cast<const char*>(titleBuf);
+        printer.setOutputFileName("file.pdf");
+        printer.setDocName(QString::fromUtf8(title));
+        painter.begin(&printer);
+        painter.end();
+    }
+    TempFileCleanup tmpFile("file.pdf");
+    QFile file("file.pdf");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    // The we expect the title to appear in the PDF as:
+    // ASCII('\title (') UTF16(\\\(\)f &oslash; hiragana o) ASCII(')').
+    // which has the following binary representation
+    const unsigned char expectedBuf[] = {
+        0x2f, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x20, 0x28, 0xfe,
+        0xff, 0x00, 0x5c, 0x5c, 0x00, 0x5c, 0x28, 0x00, 0x5c,
+        0x29, 0x00, 0x66, 0x00, 0xf8, 0x30, 0x4a, 0x29};
+    const char *expected = reinterpret_cast<const char*>(expectedBuf);
+    QVERIFY(file.readAll().contains(QByteArray(expected, 26)));
+}
+
+#endif
+
+QTEST_MAIN(tst_QPrinter)
+#include "tst_qprinter.moc"
diff --git a/tests/auto/printsupport/kernel/qprinterinfo/.gitignore b/tests/auto/printsupport/kernel/qprinterinfo/.gitignore
new file mode 100644
index 0000000000..fcef7c1997
--- /dev/null
+++ b/tests/auto/printsupport/kernel/qprinterinfo/.gitignore
@@ -0,0 +1 @@
+tst_qprinterinfo
diff --git a/tests/auto/printsupport/kernel/qprinterinfo/qprinterinfo.pro b/tests/auto/printsupport/kernel/qprinterinfo/qprinterinfo.pro
new file mode 100644
index 0000000000..88cb07f338
--- /dev/null
+++ b/tests/auto/printsupport/kernel/qprinterinfo/qprinterinfo.pro
@@ -0,0 +1,10 @@
+CONFIG += testcase
+TARGET = tst_qprinterinfo
+SOURCES  += tst_qprinterinfo.cpp
+
+QT += printsupport network testlib
+
+DEFINES += QT_USE_USING_NAMESPACE
+
+mac: CONFIG += insignificant_test # QTBUG-23060
+win32:CONFIG += insignificant_test # QTBUG-24190
diff --git a/tests/auto/printsupport/kernel/qprinterinfo/tst_qprinterinfo.cpp b/tests/auto/printsupport/kernel/qprinterinfo/tst_qprinterinfo.cpp
new file mode 100644
index 0000000000..2323dc8df3
--- /dev/null
+++ b/tests/auto/printsupport/kernel/qprinterinfo/tst_qprinterinfo.cpp
@@ -0,0 +1,393 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <QtGlobal>
+#include <QtAlgorithms>
+#include <QtNetwork/QHostInfo>
+#include <qprinterinfo.h>
+
+#ifdef Q_OS_UNIX
+#  include <unistd.h>
+#  include <sys/types.h>
+#  include <sys/wait.h>
+#endif
+
+Q_DECLARE_METATYPE(QRect)
+
+class tst_QPrinterInfo : public QObject
+{
+    Q_OBJECT
+
+#ifdef QT_NO_PRINTER
+public slots:
+    void initTestCase();
+#else
+private slots:
+    void testForDefaultPrinter();
+    void testForPrinters();
+    void testForPaperSizes();
+    void testConstructors();
+    void testAssignment();
+
+private:
+    void macFixNameFormat(QString *printerName);
+    QString getDefaultPrinterFromSystem();
+    QStringList getPrintersFromSystem();
+
+    QString getOutputFromCommand(const QStringList& command);
+#endif
+};
+
+#ifdef QT_NO_PRINTER
+void tst_QPrinterInfo::initTestCase()
+{
+    QSKIP("This test requires printing support");
+}
+
+#else
+
+void tst_QPrinterInfo::macFixNameFormat(QString *printerName)
+{
+// Modify the format of the printer name to match Qt, lpstat returns
+// foo___domain_no, Qt returns foo @ domain.no
+#ifdef Q_OS_MAC
+    printerName->replace(QLatin1String("___"), QLatin1String(" @ "));
+    printerName->replace(QLatin1String("_"), QLatin1String("."));
+#else
+    Q_UNUSED(printerName);
+#endif
+}
+
+QString tst_QPrinterInfo::getDefaultPrinterFromSystem()
+{
+    QStringList command;
+    command << "lpstat" << "-d";
+    QString output = getOutputFromCommand(command);
+
+    QRegExp noDefaultReg("[^:]*no .*default");
+    int pos = noDefaultReg.indexIn(output);
+    if (pos >= 0) {
+        return QString();
+    }
+
+    QRegExp defaultReg("default.*: *([a-zA-Z0-9_-]+)");
+    defaultReg.indexIn(output);
+    QString printer = defaultReg.cap(1);
+    macFixNameFormat(&printer);
+    return printer;
+}
+
+QStringList tst_QPrinterInfo::getPrintersFromSystem()
+{
+    QStringList ans;
+
+    QStringList command;
+    command << "lpstat" << "-p";
+    QString output = getOutputFromCommand(command);
+    QStringList list = output.split(QChar::fromLatin1('\n'));
+
+    QRegExp reg("^[Pp]rinter ([.a-zA-Z0-9-_@]+)");
+    for (int c = 0; c < list.size(); ++c) {
+        if (reg.indexIn(list[c]) >= 0) {
+            QString printer = reg.cap(1);
+            macFixNameFormat(&printer);
+            ans << printer;
+        }
+    }
+
+    return ans;
+}
+
+// This function does roughly the same as the `command substitution` in
+// the shell.
+QString tst_QPrinterInfo::getOutputFromCommand(const QStringList& command)
+{
+// The command execution does nothing on non-unix systems.
+#ifdef Q_OS_UNIX
+    int pid;
+    int status = 0;
+    int pipePtr[2];
+
+    // Create a pipe that is shared between parent and child process.
+    if (pipe(pipePtr) < 0) {
+        return QString();
+    }
+    pid = fork();
+    if (pid < 0) {
+        close(pipePtr[0]);
+        close(pipePtr[1]);
+        return QString();
+    } else if (pid == 0) {
+        // In child.
+        // Close the reading end.
+        close(pipePtr[0]);
+        // Redirect stdout to the pipe.
+        if (dup2(pipePtr[1], 1) < 0) {
+            exit(1);
+        }
+
+        char** argv = new char*[command.size()+1];
+        for (int c = 0; c < command.size(); ++c) {
+            argv[c] = new char[command[c].size()+1];
+            strcpy(argv[c], command[c].toLatin1().data());
+        }
+        argv[command.size()] = NULL;
+        execvp(argv[0], argv);
+        // Shouldn't get here, but it's possible if command is not found.
+        close(pipePtr[1]);
+        close(1);
+        for (int c = 0; c < command.size(); ++c) {
+            delete [] argv[c];
+        }
+        delete [] argv;
+        exit(1);
+    } else {
+        // In parent.
+        // Close the writing end.
+        close(pipePtr[1]);
+
+        QFile pipeRead;
+        if (!pipeRead.open(pipePtr[0], QIODevice::ReadOnly)) {
+            close(pipePtr[0]);
+            return QString();
+        }
+        QByteArray array;
+        array = pipeRead.readAll();
+        pipeRead.close();
+        close(pipePtr[0]);
+        wait(&status);
+        return QString(array);
+    }
+#else
+	return QString();
+#endif
+}
+
+void tst_QPrinterInfo::testForDefaultPrinter()
+{
+#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
+# ifdef Q_OS_WIN32
+    if (QHostInfo::localHostName() == "fantomet" || QHostInfo::localHostName() == "bobo") {
+        QWARN("Test is hardcoded to \"fantomet\" and \"bobo\" on Windows and may fail");
+    } else {
+        QSKIP("Test is hardcoded to \"fantomet\" and \"bobo\" on Windows");
+    }
+    QString defSysPrinter;
+    if (QHostInfo::localHostName() == "fantomet") {
+        defSysPrinter = "Yacc (Lexmark Optra T610 PS3)";
+    } else if (QHostInfo::localHostName() == "bobo") {
+        defSysPrinter = "press";
+    }
+# else
+    QString defSysPrinter = getDefaultPrinterFromSystem();
+# endif
+    if (defSysPrinter == "")
+        QSKIP("No default printer available");
+
+    QList<QPrinterInfo> list = QPrinterInfo::availablePrinters();
+    bool found = false;
+    for (int c = 0; c < list.size(); ++c) {
+        if (list[c].isDefault()) {
+            QVERIFY(list.at(c).printerName() == defSysPrinter);
+            QVERIFY(!list.at(c).isNull());
+            found = true;
+        } else {
+            QVERIFY(list.at(c).printerName() != defSysPrinter);
+            QVERIFY(!list.at(c).isNull());
+        }
+    }
+
+    if (!found && defSysPrinter != "") QFAIL("No default printer reported by Qt, although there is one");
+#else
+    QSKIP("Test doesn't work on non-Unix");
+#endif
+}
+
+void tst_QPrinterInfo::testForPrinters()
+{
+#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
+# ifdef Q_OS_WIN32
+    if (QHostInfo::localHostName() == "fantomet" || QHostInfo::localHostName() == "bobo") {
+        QWARN("Test is hardcoded to \"fantomet\" and \"bobo\" on Windows and may fail");
+    } else {
+        QSKIP("Test is hardcoded to \"fantomet\" and \"bobo\" on Windows");
+    }
+    QStringList sysPrinters;
+    if (QHostInfo::localHostName() == "fantomet") {
+        sysPrinters
+                << "Press"
+                << "Canon PS-IPU Color Laser Copier v52.3"
+                << "EPSON EPL-N4000 PS3"
+                << "Kroksleiven"
+                << "Lexmark Optra Color 1200 PS"
+                << "Yacc (Lexmark Optra T610 PCL)"
+                << "Yacc (Lexmark Optra T610 PS3)"
+                ;
+    } else if (QHostInfo::localHostName() == "bobo") {
+        sysPrinters
+                << "press"
+                << "finnmarka"
+                << "nordmarka"
+                ;
+    }
+# else
+    QStringList sysPrinters = getPrintersFromSystem();
+# endif
+    QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
+
+    QCOMPARE(printers.size(), sysPrinters.size());
+
+    QHash<QString, bool> qtPrinters;
+
+    for (int j = 0; j < printers.size(); ++j) {
+        qtPrinters.insert(printers.at(j).printerName(), !printers.at(j).isNull());
+    }
+
+    for (int i = 0; i < sysPrinters.size(); ++i) {
+        if (!qtPrinters.value(sysPrinters.at(i))) {
+            qDebug() << "Available printers: " << qtPrinters;
+            QFAIL(qPrintable(QString("Printer '%1' reported by system, but not reported by Qt").arg(sysPrinters.at(i))));
+        }
+    }
+#else
+    QSKIP("Test doesn't work on non-Unix");
+#endif
+}
+
+void tst_QPrinterInfo::testForPaperSizes()
+{
+QSKIP("PaperSize feature doesn't work on Windows, fails on Mac, and is unstable on Linux");
+    // This test is based on common printers found at the Oslo
+    // office. It is likely to be skipped or fail for other locations.
+    QStringList hardPrinters;
+    hardPrinters << "Finnmarka" << "Huldra";
+
+    QList<QList<QPrinter::PaperSize> > hardSizes;
+    hardSizes
+            << QList<QPrinter::PaperSize>()
+            << QList<QPrinter::PaperSize>()
+            ;
+    hardSizes[0] // Finnmarka
+            << QPrinter::Letter
+            << QPrinter::A4
+            << QPrinter::A3
+            << QPrinter::A5
+            << QPrinter::B4
+            << QPrinter::B5
+            << QPrinter::Custom // COM10
+            << QPrinter::Custom // C5
+            << QPrinter::Custom // DL
+            << QPrinter::Custom // Monarch
+            << QPrinter::Executive
+            << QPrinter::Custom // Foolscap
+            << QPrinter::Custom // ISO B5
+            << QPrinter::Ledger
+            << QPrinter::Legal
+            << QPrinter::Custom // Japanese Post Card
+            << QPrinter::Custom // Invoice
+            ;
+    hardSizes[1] // Huldra
+            << QPrinter::Custom // Not listed at http://localhost:631/, name "Custom"
+            << QPrinter::Letter
+            << QPrinter::A4
+            << QPrinter::A5
+            << QPrinter::A6
+            << QPrinter::B5
+            << QPrinter::Custom // #5 1/2 Envelope
+            << QPrinter::Custom // 6x9 Envelope
+            << QPrinter::Custom // #10 Envelope
+            << QPrinter::Custom // A7 Envelope
+            << QPrinter::Custom // C5 Envelope
+            << QPrinter::Custom // DL Envelope
+            << QPrinter::Custom // Monarch Envelope
+            << QPrinter::Custom // #6 3/4 Envelope
+            << QPrinter::Executive
+            << QPrinter::Custom // US Folio
+            << QPrinter::Custom // Index Card
+            << QPrinter::Custom // ISO B5
+            << QPrinter::Legal
+            << QPrinter::Custom // Statement
+            ;
+
+    QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
+    for (int i = 0; i < printers.size(); ++i) {
+        for (int j = 0; j < hardPrinters.size(); ++j) {
+            if (printers[i].printerName() == hardPrinters[j]) {
+                QList<QPrinter::PaperSize> sizes = printers[i].supportedPaperSizes();
+                qSort(sizes);
+                qSort(hardSizes[j]);
+                QCOMPARE(sizes, hardSizes[j]);
+            }
+        }
+    }
+}
+
+void tst_QPrinterInfo::testConstructors()
+{
+    QList<QPrinterInfo> prns(QPrinterInfo::availablePrinters());
+
+    for (int c = 0; c < prns.size(); ++c) {
+        QList<QPrinter::PaperSize> list1, list2;
+        list1 = prns[c].supportedPaperSizes();
+        QPrinter pr(prns[c]);
+        list2 = QPrinterInfo(pr).supportedPaperSizes();
+        QCOMPARE(list2, list1);
+    }
+}
+
+void tst_QPrinterInfo::testAssignment()
+{
+    QList<QPrinterInfo> prns(QPrinterInfo::availablePrinters());
+
+    for (int c = 0; c < prns.size(); ++c) {
+        QPrinterInfo pi = QPrinterInfo::defaultPrinter();
+        pi = prns[c];
+        QCOMPARE(pi.printerName(), prns[c].printerName());
+        QCOMPARE(pi.supportedPaperSizes(), prns[c].supportedPaperSizes());
+    }
+}
+
+#endif
+
+QTEST_MAIN(tst_QPrinterInfo)
+#include "tst_qprinterinfo.moc"