AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
61dabf97f2
qt5base-lts/tests/auto/printsupport/kernel/qprinterinfo/tst_qprinterinfo.cpp
Andy Shaw c1cd8df84e Fix the test for non-English based setups 
Unsetting the SOFTWARE environment variable will force lpstat to use
English for the output, so we can ensure that the test will pass
regardless of the language used for the machine.

Change-Id: Iddf5e8aadaa546ae3e0dd172df84e4e43ee02c2a
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
2017-08-23 08:07:37 +00:00

393 lines
15 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <QtGlobal>
#include <QtAlgorithms>
#include <QtPrintSupport/qprinterinfo.h>
#include <algorithm>
#ifdef Q_OS_UNIX
# include <unistd.h>
# include <sys/types.h>
# include <sys/wait.h>
#endif
class tst_QPrinterInfo : public QObject
{
Q_OBJECT
public slots:
#ifdef QT_NO_PRINTER
void initTestCase();
void cleanupTestCase();
#else
private slots:
#ifndef Q_OS_WIN32
void testForDefaultPrinter();
void testForPrinters();
#endif
void testForPaperSizes();
void testConstructors();
void testAssignment();
void namedPrinter();
private:
QString getDefaultPrinterFromSystem();
QStringList getPrintersFromSystem();
#ifdef Q_OS_UNIX
QString getOutputFromCommand(const QStringList& command);
#endif // Q_OS_UNIX
#endif
};
#ifdef QT_NO_PRINTER
void tst_QPrinterInfo::initTestCase()
{
QSKIP("This test requires printing support");
}
void tst_QPrinterInfo::cleanupTestCase()
{
QSKIP("This test requires printing support");
}
#else
QString tst_QPrinterInfo::getDefaultPrinterFromSystem()
{
QString printer;
#ifdef Q_OS_WIN32
// TODO "cscript c:\windows\system32\prnmngr.vbs -g"
#endif // Q_OS_WIN32
#ifdef Q_OS_UNIX
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);
printer = defaultReg.cap(1);
#endif // Q_OS_UNIX
return printer;
}
QStringList tst_QPrinterInfo::getPrintersFromSystem()
{
QStringList ans;
#ifdef Q_OS_WIN32
// TODO "cscript c:\windows\system32\prnmngr.vbs -l"
#endif // Q_OS_WIN32
#ifdef Q_OS_UNIX
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);
ans << printer;
}
}
#endif // Q_OS_UNIX
return ans;
}
#ifdef Q_OS_UNIX
// This function does roughly the same as the `command substitution` in
// the shell.
QString getOutputFromCommandInternal(const QStringList &command)
{
// The command execution does nothing on non-unix systems.
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);
}
}
QString tst_QPrinterInfo::getOutputFromCommand(const QStringList &command)
{
// Forces the ouptut from the command to be in English
const QByteArray origSoftwareEnv = qgetenv("SOFTWARE");
qputenv("SOFTWARE", QByteArray());
QString output = getOutputFromCommandInternal(command);
qputenv("SOFTWARE", origSoftwareEnv);
return output;
}
#endif
// Windows test support not yet implemented
#ifndef Q_OS_WIN32
void tst_QPrinterInfo::testForDefaultPrinter()
{
QString testPrinter = getDefaultPrinterFromSystem();
QString defaultPrinter = QPrinterInfo::defaultPrinter().printerName();
QString availablePrinter;
int availablePrinterDefaults = 0;
QList<QPrinterInfo> list = QPrinterInfo::availablePrinters();
for (int c = 0; c < list.size(); ++c) {
if (list[c].isDefault()) {
availablePrinter = list.at(c).printerName();
++availablePrinterDefaults;
}
}
qDebug() << "Test believes Default Printer = " << testPrinter;
qDebug() << "QPrinterInfo::defaultPrinter() believes Default Printer = " << defaultPrinter;
qDebug() << "QPrinterInfo::availablePrinters() believes Default Printer = " << availablePrinter;
QCOMPARE(testPrinter, defaultPrinter);
QCOMPARE(testPrinter, availablePrinter);
if (!availablePrinter.isEmpty())
QCOMPARE(availablePrinterDefaults, 1);
}
#endif
// Windows test support not yet implemented
#ifndef Q_OS_WIN32
void tst_QPrinterInfo::testForPrinters()
{
QStringList testPrinters = getPrintersFromSystem();
QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
QStringList qtPrinters;
for (int i = 0; i < printers.size(); ++i)
qtPrinters.append(printers.at(i).printerName());
std::sort(testPrinters.begin(), testPrinters.end());
std::sort(qtPrinters.begin(), qtPrinters.end());
qDebug() << "Test believes Available Printers = " << testPrinters;
qDebug() << "QPrinterInfo::availablePrinters() believes Available Printers = " << qtPrinters;
QCOMPARE(qtPrinters.size(), testPrinters.size());
for (int i = 0; i < testPrinters.size(); ++i)
QCOMPARE(qtPrinters.at(i), testPrinters.at(i));
}
#endif
void tst_QPrinterInfo::testForPaperSizes()
{
// TODO Old PaperSize test dependent on physical printer installed, new generic test required
// In the meantime just exercise the code path and print-out for inspection.
QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
for (int i = 0; i < printers.size(); ++i) {
qDebug() << "Printer : " << printers.at(i).printerName() << printers.at(i).defaultPageSize();
qDebug() << "Paper Sizes : " << printers.at(i).supportedPageSizes();
qDebug() << "Custom Sizes : " << printers.at(i).supportsCustomPageSizes();
qDebug() << "Physical Sizes: " << printers.at(i).minimumPhysicalPageSize()
<< printers.at(i).maximumPhysicalPageSize();
qDebug() << "";
}
}
void tst_QPrinterInfo::testConstructors()
{
QPrinterInfo null;
QCOMPARE(null.printerName(), QString());
QVERIFY(null.isNull());
QPrinterInfo null2(null);
QVERIFY(null2.isNull());
QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
for (int i = 0; i < printers.size(); ++i) {
QPrinterInfo copy1(printers.at(i));
QCOMPARE(copy1.printerName(), printers.at(i).printerName());
QCOMPARE(copy1.description(), printers.at(i).description());
QCOMPARE(copy1.location(), printers.at(i).location());
QCOMPARE(copy1.makeAndModel(), printers.at(i).makeAndModel());
QCOMPARE(copy1.isNull(), printers.at(i).isNull());
QCOMPARE(copy1.isDefault(), printers.at(i).isDefault());
QCOMPARE(copy1.isRemote(), printers.at(i).isRemote());
QCOMPARE(copy1.state(), printers.at(i).state());
QCOMPARE(copy1.supportedPageSizes(), printers.at(i).supportedPageSizes());
QCOMPARE(copy1.defaultPageSize(), printers.at(i).defaultPageSize());
QCOMPARE(copy1.supportsCustomPageSizes(), printers.at(i).supportsCustomPageSizes());
QCOMPARE(copy1.minimumPhysicalPageSize(), printers.at(i).minimumPhysicalPageSize());
QCOMPARE(copy1.maximumPhysicalPageSize(), printers.at(i).maximumPhysicalPageSize());
QCOMPARE(copy1.supportedPaperSizes(), printers.at(i).supportedPaperSizes());
QCOMPARE(copy1.supportedSizesWithNames(), printers.at(i).supportedSizesWithNames());
QCOMPARE(copy1.supportedResolutions(), printers.at(i).supportedResolutions());
QCOMPARE(copy1.defaultDuplexMode(), printers.at(i).defaultDuplexMode());
QCOMPARE(copy1.supportedDuplexModes(), printers.at(i).supportedDuplexModes());
QPrinter printer(printers.at(i));
QPrinterInfo copy2(printer);
QCOMPARE(copy2.printerName(), printers.at(i).printerName());
QCOMPARE(copy2.description(), printers.at(i).description());
QCOMPARE(copy2.location(), printers.at(i).location());
QCOMPARE(copy2.makeAndModel(), printers.at(i).makeAndModel());
QCOMPARE(copy2.isNull(), printers.at(i).isNull());
QCOMPARE(copy2.isDefault(), printers.at(i).isDefault());
QCOMPARE(copy2.isRemote(), printers.at(i).isRemote());
QCOMPARE(copy2.state(), printers.at(i).state());
QCOMPARE(copy2.supportedPageSizes(), printers.at(i).supportedPageSizes());
QCOMPARE(copy2.defaultPageSize(), printers.at(i).defaultPageSize());
QCOMPARE(copy2.supportsCustomPageSizes(), printers.at(i).supportsCustomPageSizes());
QCOMPARE(copy2.minimumPhysicalPageSize(), printers.at(i).minimumPhysicalPageSize());
QCOMPARE(copy2.maximumPhysicalPageSize(), printers.at(i).maximumPhysicalPageSize());
QCOMPARE(copy2.supportedPaperSizes(), printers.at(i).supportedPaperSizes());
QCOMPARE(copy2.supportedSizesWithNames(), printers.at(i).supportedSizesWithNames());
QCOMPARE(copy2.supportedResolutions(), printers.at(i).supportedResolutions());
QCOMPARE(copy2.defaultDuplexMode(), printers.at(i).defaultDuplexMode());
QCOMPARE(copy2.supportedDuplexModes(), printers.at(i).supportedDuplexModes());
}
}
void tst_QPrinterInfo::testAssignment()
{
QPrinterInfo null;
QVERIFY(null.isNull());
QPrinterInfo null2;
null2 = null;
QVERIFY(null2.isNull());
QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
for (int i = 0; i < printers.size(); ++i) {
QPrinterInfo copy;
copy = printers.at(i);
QCOMPARE(copy.printerName(), printers.at(i).printerName());
QCOMPARE(copy.description(), printers.at(i).description());
QCOMPARE(copy.location(), printers.at(i).location());
QCOMPARE(copy.makeAndModel(), printers.at(i).makeAndModel());
QCOMPARE(copy.isNull(), printers.at(i).isNull());
QCOMPARE(copy.isDefault(), printers.at(i).isDefault());
QCOMPARE(copy.isRemote(), printers.at(i).isRemote());
QCOMPARE(copy.state(), printers.at(i).state());
QCOMPARE(copy.supportedPageSizes(), printers.at(i).supportedPageSizes());
QCOMPARE(copy.defaultPageSize(), printers.at(i).defaultPageSize());
QCOMPARE(copy.supportsCustomPageSizes(), printers.at(i).supportsCustomPageSizes());
QCOMPARE(copy.minimumPhysicalPageSize(), printers.at(i).minimumPhysicalPageSize());
QCOMPARE(copy.maximumPhysicalPageSize(), printers.at(i).maximumPhysicalPageSize());
QCOMPARE(copy.supportedResolutions(), printers.at(i).supportedResolutions());
QCOMPARE(copy.defaultDuplexMode(), printers.at(i).defaultDuplexMode());
QCOMPARE(copy.supportedDuplexModes(), printers.at(i).supportedDuplexModes());
}
}
void tst_QPrinterInfo::namedPrinter()
{
QList<QPrinterInfo> printers = QPrinterInfo::availablePrinters();
QStringList printerNames;
foreach (const QPrinterInfo &pi, printers) {
QPrinterInfo pi2 = QPrinterInfo::printerInfo(pi.printerName());
QCOMPARE(pi2.printerName(), pi.printerName());
QCOMPARE(pi2.description(), pi.description());
QCOMPARE(pi2.location(), pi.location());
QCOMPARE(pi2.makeAndModel(), pi.makeAndModel());
QCOMPARE(pi2.isNull(), pi.isNull());
QCOMPARE(pi2.isDefault(), pi.isDefault());
QCOMPARE(pi2.isRemote(), pi.isRemote());
QCOMPARE(pi2.supportedPageSizes(), pi.supportedPageSizes());
QCOMPARE(pi2.defaultPageSize(), pi.defaultPageSize());
QCOMPARE(pi2.supportsCustomPageSizes(), pi.supportsCustomPageSizes());
QCOMPARE(pi2.minimumPhysicalPageSize(), pi.minimumPhysicalPageSize());
QCOMPARE(pi2.maximumPhysicalPageSize(), pi.maximumPhysicalPageSize());
QCOMPARE(pi2.supportedResolutions(), pi.supportedResolutions());
QCOMPARE(pi2.defaultDuplexMode(), pi.defaultDuplexMode());
QCOMPARE(pi2.supportedDuplexModes(), pi.supportedDuplexModes());
}
}
#endif // QT_NO_PRINTER
QTEST_MAIN(tst_QPrinterInfo)
#include "tst_qprinterinfo.moc"
Reference in New Issue View Git Blame Copy Permalink