tst_headers.cpp - mozsearch

++ // Copyright (C) 2017 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++

++ #include <QtCore/QtCore>

++ #include <QtTest/QtTest>

++

++ class tst_Headers: public QObject

++ {

++     Q_OBJECT

++ private slots:

++     void initTestCase();

++

++     void privateSlots_data() { allHeadersData(); }

++     void privateSlots();

++

++     void macros_data() { allHeadersData(); }

++     void macros();

++

++ private:

++     static QString explainPrivateSlot(const QString &line);

++

++     void allHeadersData();

++     QStringList headers;

++     QString qtModuleDir;

++ };

++

++ static QByteArray captureOutput(const QString &program, const QStringList &arguments, const QString &workingDirectory = QString())

++ {

++     QProcess process;

++     process.setWorkingDirectory(workingDirectory);

++     process.start(program, arguments);

++

++     if (!process.waitForFinished(30000))

++         qFatal("'%s' did not complete within 30 seconds: %s", qPrintable(program), qPrintable(process.errorString()));

++

++     if (0 != process.exitCode())

++         qFatal("Error running '%s': %s", qPrintable(program), process.readAllStandardError().constData());

++

++     return process.readAll();

++ }

++

++ static QStringList getHeaders(const QString &path)

++ {

++     // Create a QStringList of files out of the standard output

++     QString string(captureOutput("git", QStringList() << "ls-files", path));

++     QStringList entries = string.split( "\n" );

++

++     // We just want to check header files

++     entries = entries.filter(QRegularExpression("\\.h$"));

++     entries = entries.filter(QRegularExpression("^(?!ui_)"));

++

++     // Recreate the whole file path so we can open the file from disk

++     QStringList result;

++     for (const QString &entry : std::as_const(entries))

++         result += path + "/" + entry;

++

++     return result;

++ }

++

++ static QStringList getModuleHeaders(const QString &moduleRoot)

++ {

++     // Read the sync.profile file of the module and test headers that syncqt will consider deploying.

++     const QLatin1String perlReadSyncProfileExpr(

++         "use File::Spec; use Cwd 'abs_path';"

++         "$basedir = $ARGV[0];"

++         "do File::Spec->catfile($basedir, 'sync.profile');"

++         "foreach my $lib (keys(%modules)) {"

++             "my $module = $modules{$lib};"

++             "my $moduleheader = $moduleheaders{$lib};"

++             "my $is_qt = !($module =~ s/^!//);"

++             "my $joined = abs_path(File::Spec->catdir($module, $moduleheader));"

++             "push @searchPaths, $joined if ($is_qt);"

++         "}"

++         "print join(\"\\n\", @searchPaths);");

++

++     QString string(captureOutput("perl", QStringList() << "-e" << perlReadSyncProfileExpr << moduleRoot));

++     const QStringList entries = string.split("\n");

++     QStringList headers;

++     for (const QString &headersPath : entries)

++         headers += getHeaders(headersPath);

++     return headers;

++ }

++

++ void tst_Headers::initTestCase()

++ {

++     qtModuleDir = QString::fromLocal8Bit(qgetenv("QT_MODULE_TO_TEST"));

++     if (qtModuleDir.isEmpty()) {

++         QSKIP("$QT_MODULE_TO_TEST is unset - nothing to test.  Set QT_MODULE_TO_TEST to the path "

++               "of a Qt module to test.");

++     }

++

++     QDir dir(qtModuleDir);

++     QString module = dir.dirName(); // git module name, e.g. qtbase, qtdeclarative

++

++     if (module != "phonon" && module != "qttools") {

++         if (dir.exists("src")) {

++

++             /*

++                 Let all paths be relative to the directory containing the module.

++                 For example, if the full path is:

++

++                     /home/qt/build/qt5/qtbase/src/corelib/tools/qstring.h

++

++                 ... the first part of the path is useless noise, and causes the

++                 test log to look different on different machines.

++                 Cut it down to only the important part:

++

++                     qtbase/src/corelib/tools/qstring.h

++

++             */

++

++             QVERIFY(QDir::setCurrent(dir.absolutePath() + "/.."));

++

++             headers = getModuleHeaders(module);

++         }

++         if (headers.isEmpty()) {

++             QVERIFY2(module != "qtbase",

++                 "qtbase not containing any header? Something might be wrong with this test.");

++             QSKIP("It seems there are no headers in this module; this test is "

++                   "not applicable");

++         }

++     } else {

++         qWarning("Some test functions will be skipped, because we ignore them for phonon and qttools.");

++     }

++ }

++

++ void tst_Headers::allHeadersData()

++ {

++     QTest::addColumn<QString>("header");

++

++     if (headers.isEmpty())

++         QSKIP("can't find any headers in your $QT_MODULE_TO_TEST/src.");

++

++     for (const QString &hdr : std::as_const(headers)) {

++         if (hdr.contains("/3rdparty/") || hdr.endsWith("/src/tools/uic/qclass_lib_map.h"))

++             continue;

++

++         QTest::newRow(qPrintable(hdr)) << hdr;

++     }

++ }

++

++ QString tst_Headers::explainPrivateSlot(const QString& line)

++ {

++     // Extract private slot from a line like:

++     //  Q_PRIVATE_SLOT(d_func(), void fooBar(...))

++     QRegularExpression re("^\\s+Q_PRIVATE_SLOT\\([^,]+,\\s*(.+)\\)\\s*$");

++     QString slot = line;

++     QRegularExpressionMatch match = re.match(slot);

++     if (match.hasMatch())

++         slot = match.captured(1).simplified();

++

++     return QString(

++         "Private slot `%1' should be named starting with _q_, to reduce the risk of collisions "

++         "with signals/slots in user classes"

++     ).arg(slot);

++ }

++

++ void tst_Headers::privateSlots()

++ {

++     QFETCH(QString, header);

++

++     if (header.endsWith("_p.h"))

++         return;

++

++     QFile f(header);

++     QVERIFY2(f.open(QIODevice::ReadOnly), qPrintable(f.errorString()));

++

++     const QStringList content = QString::fromLocal8Bit(f.readAll()).split("\n");

++     for (const QString &line : content) {

++         if (line.contains("Q_PRIVATE_SLOT(") && !line.contains("define Q_PRIVATE_SLOT"))

++             QVERIFY2(line.contains("_q_"), qPrintable(explainPrivateSlot(line)));

++     }

++ }

++

++ void tst_Headers::macros()

++ {

++     QFETCH(QString, header);

++

++     if (header.endsWith("_p.h") || header.endsWith("_pch.h")

++         || header.contains("global/qconfig-") || header.endsWith("/qconfig.h")

++         || header.endsWith("src/corelib/global/qcompilerdetection.h")

++         || header.endsWith("src/corelib/global/qprocessordetection.h")

++         || header.endsWith("src/corelib/global/qsystemdetection.h")

++         || header.endsWith("src/gui/opengl/qopengles2ext.h")

++         || header.endsWith("src/gui/opengl/qopenglext.h")

++         || header.contains("/snippets/")

++         || header.contains("/src/tools/") || header.contains("/src/plugins/")

++         || header.contains("/src/imports/")

++         || header.contains("/src/uitools/")

++         || header.contains("/src/daemon")

++         || header.endsWith("/qiconset.h") || header.endsWith("/qfeatures.h")

++         || header.endsWith("qt_windows.h")

++         // qtsvg.git files

++         || header.endsWith("src/svg/qsvgfunctions_wince.h"))

++         return;

++

++     QFile f(header);

++     QVERIFY2(f.open(QIODevice::ReadOnly), qPrintable(f.errorString()));

++

++     QByteArray data = f.readAll();

++     QStringList content = QString::fromLocal8Bit(data.replace('\r', "")).split("\n");

++

++     // "signals" and "slots" should be banned in public headers

++     // headers which use signals/slots wouldn't compile if Qt is configured with QT_NO_KEYWORDS

++     QVERIFY2(content.indexOf(QRegularExpression("\\bslots\\s*:")) == -1, "Header contains `slots' - use `Q_SLOTS' instead!");

++     QVERIFY2(content.indexOf(QRegularExpression("\\bsignals\\s*:")) == -1, "Header contains `signals' - use `Q_SIGNALS' instead!");

++

++     if (header.contains("/sql/drivers/") || header.contains("/arch/qatomic")

++         || header.contains(QRegularExpression("q.*global\\.h$"))

++         || header.endsWith("qwindowdefs_win.h"))

++         return;

++

++     int beginNamespace = content.indexOf(QRegularExpression("QT_BEGIN_NAMESPACE(_[A-Z_]+)?"));

++     int endNamespace = content.lastIndexOf(QRegularExpression("QT_END_NAMESPACE(_[A-Z_]+)?"));

++     QVERIFY(beginNamespace != -1);

++     QVERIFY(endNamespace != -1);

++     QVERIFY(beginNamespace < endNamespace);

++ }

++

++ QTEST_MAIN(tst_Headers)

++ #include "tst_headers.moc"

Revision control