tst_bic.cpp - mozsearch

qt/qtqa/tests/postbuild/bic/tst_bic.cpp (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2020 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>

#include "qbic.h"

#include "global.h"

#include <stdlib.h>

typedef QPair<int, int> Version;

static QString compiler()

#if defined(Q_CC_CLANG) && defined(__INTEL_CLANG_COMPILER)

    return QLatin1String("icx");

#elif defined(Q_CC_CLANG)

    return QLatin1String("clang++");

#elif defined(Q_CC_GNU)

    return QLatin1String("g++");

#elif defined(Q_CC_MSVC)

    return QLatin1String("cl");

#else

    return QLatin1String("unknown");

#endif

bool compilerVersion(const QString &compiler, QString *output, Version *version, QString *errorMessage)

    *version = Version(-1, -1);

    output->clear();

#ifndef QT_NO_PROCESS

    // Run compiler to obtain version information.

    QProcess proc;

    proc.start(compiler, QStringList(QLatin1String("--version")), QIODevice::ReadOnly);

    if (!proc.waitForStarted()) {

        *errorMessage = QLatin1String("Cannot launch: ") + compiler + QLatin1String(": ") + proc.errorString();

        return false;

    if (!proc.waitForFinished()) {

        proc.kill();

        *errorMessage = compiler + QLatin1String(" did not terminate.");

        return false;

    *output = QString::fromLocal8Bit(proc.readAllStandardOutput());

    // Extract version from last token of first line ("g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2 [build (prerelease)]\n...")

    QRegularExpression versionPattern(QLatin1String("^[^(]+\\([^)]+\\) (\\d+)\\.(\\d+)\\.\\d+.*$"),

                                      QRegularExpression::MultilineOption);

    Q_ASSERT(versionPattern.isValid());

    QRegularExpressionMatch match = versionPattern.match(*output);

    if (!match.hasMatch()) {

        *errorMessage = compiler + QLatin1String(" produced unexpected output: \"")

            + *output + QLatin1String("\", matching up to ") + QString::number(match.capturedLength());

        return false;

    version->first = match.captured(1).toInt();

    version->second = match.captured(2).toInt();

    return true;

#else // !QT_NO_PROCESS

    Q_UNUSED(compiler);

    *errorMessage = QLatin1String("Platform does not support QProcess");

    return false;

#endif

static QStringList compilerArguments(const QString &compiler, const QStringList &incPaths)

    Q_UNUSED(compiler);

    QStringList result;

    result << "-c"

         << incPaths

#ifdef Q_OS_MAC

        << "-arch" << "i386" // Always use 32-bit data on Mac.

#endif

#ifndef Q_OS_WIN

         << "-I/usr/X11R6/include/"

#endif

         << "-DQT_NO_STL"

         << "-xc++"

#if !defined(Q_OS_AIX) && !defined(Q_OS_WIN)

         << "-o" << "/dev/null"

#endif

#if __GNUC__ >= 8

         << "-fdump-lang-class"

#else

         << "-fdump-class-hierarchy"

#endif

         << "-std=c++17"

         << "-fPIC"; // As of 5.4, "reduce relocations" requires "-fPIC"

    return result;

static const char noneSuchFileSuffix[] = "nonsuch";

static QString fileSuffix(const QString &compiler, const Version &compilerVersion)

    Q_UNUSED(compiler);

    Q_UNUSED(compilerVersion);

    QString result;

#if !defined(Q_CC_GNU)

    return result;

#endif

#if defined Q_OS_LINUX

# if defined(__powerpc__) && !defined(__powerpc64__)

    result = QLatin1String("linux-gcc-ppc32");

# elif defined(__amd64__)

    result = QLatin1String("linux-gcc-amd64");

# elif defined(__i386__)

    result = QLatin1String("linux-gcc-ia32");

# elif defined(__arm__)

    result = QLatin1String("linux-gcc-arm");

# endif

#elif defined Q_OS_MACOS && defined(__powerpc__)

    result = QLatin1String("macx-gcc-ppc32");

#elif defined Q_OS_MACOS && defined(__i386__)

    result = QLatin1String("macx-gcc-ia32");

#elif defined Q_OS_MACOS && defined(__amd64__)

    result = QLatin1String("macx-gcc-amd64");

#elif defined Q_OS_WIN && defined Q_CC_GNU

    result = QLatin1String("win32-gcc-ia32");

#else

    result = QLatin1String(noneSuchFileSuffix);

#endif

    return result;

class tst_Bic: public QObject

    Q_OBJECT

public:

    tst_Bic(const char *appFilePath);

#ifndef QT_NO_PROCESS

    QBic::Info getCurrentInfo(const QString &libName);

#endif

    QHash<QString, QBic::Info> cachedCurrentInfo;

private slots:

    void initTestCase();

    void cleanupTestCase();

    void sizesAndVTables_data();

    void sizesAndVTables();

private:

    QBic bic;

    QString qtModuleDir;

    QString qtDir;

    QString qtSourceDir;

    QStringList qtModules;

    QHash<QString, QString> modules;

    QStringList incPaths;

    QString m_compiler;

    Version m_compilerVersion;

    QString m_fileSuffix;

    QStringList m_compilerArguments;

    const char *m_appFilePath;

};

typedef QPair<QString, QString> QStringPair;

tst_Bic::tst_Bic(const char *appFilePath)

    : m_compiler(compiler())

    , m_compilerVersion(0, 0)

    , m_appFilePath(appFilePath)

    bic.addBlacklistedClass(QLatin1String("std::*"));

    bic.addBlacklistedClass(QLatin1String("qIsNull*"));

    bic.addBlacklistedClass(QLatin1String("_*"));

    bic.addBlacklistedClass(QLatin1String("<anonymous*"));

    /* some system stuff we don't care for */

    bic.addBlacklistedClass(QLatin1String("drand"));

    bic.addBlacklistedClass(QLatin1String("itimerspec"));

    bic.addBlacklistedClass(QLatin1String("lconv"));

    bic.addBlacklistedClass(QLatin1String("pthread_attr_t"));

    bic.addBlacklistedClass(QLatin1String("random"));

    bic.addBlacklistedClass(QLatin1String("sched_attr"));

    bic.addBlacklistedClass(QLatin1String("sched_param"));

    bic.addBlacklistedClass(QLatin1String("sigcontext"));

    bic.addBlacklistedClass(QLatin1String("sigaltstack"));

    bic.addBlacklistedClass(QLatin1String("timespec"));

    bic.addBlacklistedClass(QLatin1String("timeval"));

    bic.addBlacklistedClass(QLatin1String("timex"));

    bic.addBlacklistedClass(QLatin1String("tm"));

    bic.addBlacklistedClass(QLatin1String("ucontext64"));

    bic.addBlacklistedClass(QLatin1String("ucontext"));

    bic.addBlacklistedClass(QLatin1String("wait"));

    /* QtOpenGL includes qt_windows.h, and some SDKs don't have these structs present */

    bic.addBlacklistedClass(QLatin1String("tagTITLEBARINFO"));

    bic.addBlacklistedClass(QLatin1String("tagMENUITEMINFOA"));

    bic.addBlacklistedClass(QLatin1String("tagMENUITEMINFOW"));

    bic.addBlacklistedClass(QLatin1String("tagENHMETAHEADER"));

    /* some bug in gcc also reported template instanciations */

    bic.addBlacklistedClass(QLatin1String("QTypeInfo<*>"));

    bic.addBlacklistedClass(QLatin1String("QMetaTypeId<*>"));

    bic.addBlacklistedClass(QLatin1String("QVector<QGradientStop>*"));

    /* this guy is never instantiated, just for compile-time checking */

    bic.addBlacklistedClass(QLatin1String("QMap<*>::PayloadNode"));

    /* QFileEngine was removed in 4.1 */

    bic.addBlacklistedClass(QLatin1String("QFileEngine"));

    bic.addBlacklistedClass(QLatin1String("QFileEngineHandler"));

    bic.addBlacklistedClass(QLatin1String("QFlags<QFileEngine::FileFlag>"));

    /* QTest::toString lambda error is false positive */

    bic.addBlacklistedClass(QRegularExpression::escape(QLatin1String("QTest::toString(const T&) [with T = QUrl]::__lambda0")));

    /* Private classes */

    bic.addBlacklistedClass(QLatin1String("QBrushData"));

    bic.addBlacklistedClass(QLatin1String("QObjectData"));

    bic.addBlacklistedClass(QLatin1String("QAtomic"));

    bic.addBlacklistedClass(QLatin1String("QBasicAtomic"));

    bic.addBlacklistedClass(QLatin1String("QRegion::QRegionData"));

    bic.addBlacklistedClass(QLatin1String("QtConcurrent::ThreadEngineSemaphore"));

    bic.addBlacklistedClass(QLatin1String("QDrawPixmaps::Data"));

    bic.addBlacklistedClass(QLatin1String("QS60Style"));

    bic.addBlacklistedClass(QLatin1String("QPointerBase"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctionsPrivate"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLExtraFunctionsPrivate::Functions"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLExtraFunctionsPrivate"));

    bic.addBlacklistedClass(QLatin1String("QGLFunctionsPrivate"));

    bic.addBlacklistedClass(QLatin1String("QDebug::Stream"));

    bic.addBlacklistedClass(QLatin1String("QtPrivate::*"));

    /* Jambi-related classes in Designer */

    bic.addBlacklistedClass(QLatin1String("QDesignerLanguageExtension"));

    /* Frederik says it's undocumented and private :) */

    bic.addBlacklistedClass(QLatin1String("QAccessible"));

    bic.addBlacklistedClass(QLatin1String("QAccessible::QPrivateSignal"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleWidget"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleTextInterface"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleEditableTextInterface"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleValueInterface"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleTableCellInterface"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleTableInterface"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleActionInterface"));

    bic.addBlacklistedClass(QLatin1String("QAccessibleImageInterface"));

    // Accidentally made public in 5.4.0, all in separate headers that don't start with q and look out of place

    const char *accessibilityClasses[] = {

        "QAccessibleAbstractScrollArea",

        "QAccessibleAbstractSlider",

        "QAccessibleAbstractSpinBox",

        "QAccessibleButton",

        "QAccessibleCalendarWidget",

        "QAccessibleComboBox",

        "QAccessibleDial",

        "QAccessibleDialogButtonBox",

        "QAccessibleDisplay",

        "QAccessibleDockWidget",

        "QAccessibleDoubleSpinBox",

        "QAccessibleGroupBox",

        "QAccessibleLineEdit",

        "QAccessibleMainWindow",

        "QAccessibleMdiArea",

        "QAccessibleMdiSubWindow",

        "QAccessibleMenu",

        "QAccessibleMenuBar",

        "QAccessibleMenuItem",

        "QAccessiblePlainTextEdit",

        "QAccessibleProgressBar",

        "QAccessibleScrollArea",

        "QAccessibleScrollBar",

        "QAccessibleSlider",

        "QAccessibleSpinBox",

        "QAccessibleStackedWidget",

        "QAccessibleTabBar",

        "QAccessibleTable",

        "QAccessibleTableCell",

        "QAccessibleTableCornerButton",

        "QAccessibleTableHeaderCell",

        "QAccessibleTextBrowser",

        "QAccessibleTextEdit",

        "QAccessibleTextWidget",

        "QAccessibleToolBox",

        "QAccessibleToolButton",

        "QAccessibleTree",

        "QAccessibleWindowContainer"

};

    for (uint i = 0; i < sizeof(accessibilityClasses)/sizeof(char*); ++i) {

        bic.addBlacklistedClass(QLatin1String(accessibilityClasses[i]));

    /* This structure is semi-private and should never shrink */

    bic.addBlacklistedClass(QLatin1String("QVFbHeader"));

    /* Those structures have a version field that allows extension */

    bic.addBlacklistedClass(QLatin1String("QDeclarativePrivate::RegisterType"));

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::RegisterType"));

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::RegisterTypeAndRevisions"));

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::RegisterSingletonType"));

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::RegisterInterface"));

    /* this class is not used in a way that requires its size to be stable,

       but it has grown between releases */

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::AOTCompiledFunction"));

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::TypedFunction"));

    /* This class was added in a patch release */

    bic.addBlacklistedClass(QLatin1String("QQmlPrivate::AOTTrackedLocalsStorage"));

    /* according to Thiago this is a false positive */

    bic.addBlacklistedClass(QLatin1String("QLoggingCategory::AtomicBools"));

    bic.addBlacklistedClass(QLatin1String("QOperatingSystemVersion::HighSierra"));

    /* according to Sean Harmer these are a false positive (qtbase/ea80316f) */

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_1_1_DeprecatedBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_2_0_DeprecatedBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_3_0_DeprecatedBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_1_1_CoreBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_2_0_CoreBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_3_0_CoreBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_3_3_CoreBackend"));

    bic.addBlacklistedClass(QLatin1String("QOpenGLFunctions_4_3_CoreBackend"));

    /* this class is not used in a way that requires its size to be stable,

       but it has grown between releases */

    bic.addBlacklistedClass(QLatin1String("QBindingStatus"));

    /* don't bic-test Vulkan types */

    bic.addBlacklistedClass(QLatin1String("Vk*"));

    /* don't bic-test Vulkan video codec types */

    bic.addBlacklistedClass(QLatin1String("StdVideo*"));

    /* vtable churn */

    bic.addBlacklistedClass(QLatin1String("QNativeInterface::QEGLContext"));

    bic.addBlacklistedClass(QLatin1String("QNativeInterface::QWaylandApplication"));

    /* deliberately removed */

    bic.addBlacklistedClass(QLatin1String("QNativeInterface::QSGVulkanTexture*"));

    /* deliberately added in a patch release */

    bic.addBlacklistedClass(QLatin1String("QVulkanLayer"));

    bic.addBlacklistedClass(QLatin1String("QVulkanExtension"));

    bic.addBlacklistedClass(QLatin1String("QVulkanInstance"));

    bic.addBlacklistedClass(QLatin1String("QOperatingSystemVersionUnexported"));

    bic.addBlacklistedClass(QLatin1String("QAnyStringView::QCharContainer"));

    /* allowed to grow */

    bic.addBlacklistedClass(QLatin1String("QSGMaterialShader::GraphicsPipelineState"));

    /* intentionally removed */

    bic.addBlacklistedClass(QLatin1String("QDeferredDeleteEvent"));

    bic.addBlacklistedClass(QLatin1String("QUntypedPropertyData::InheritsQUntypedPropertyData"));

    /* an override added in a patch release */

    bic.addBlacklistedClass(QLatin1String("QDialogButtonBox"));

    /* likewise, an override added in another patch release */

    bic.addBlacklistedClass(QLatin1String("QRasterWindow"));

    /* intentionally ABI-unstable */

    bic.addBlacklistedClass(QLatin1String("QSignalSpy"));

    bic.addBlacklistedClass(QLatin1String("QTest::*"));

    bic.addBlacklistedClass(QLatin1String("QJSListForInIterator"));

    bic.addBlacklistedClass(QLatin1String("QJSListForOfIterator"));

void tst_Bic::initTestCase()

    const char moduleVar[] = "QT_MODULE_TO_TEST";

#ifndef Q_OS_WIN

    const char qmake[] = "qmake";

#else

    const char qmake[] = "qmake.exe";

#endif

    qWarning("This test needs the correct qmake in PATH, we need it to generate INCPATH for qt modules.");

    QString moduleEnvVar = QFile::decodeName(qgetenv(moduleVar));

    bool qt = moduleEnvVar.startsWith(QLatin1String("qt="));

    if (qt) {

        qtDir = QFile::decodeName(qgetenv("QTDIR"));

        if (qtDir.isEmpty())

            QSKIP("QTDIR is unset. QTDIR must point to Qt headers when testing in qt mode.");

        QStringList qtComponents = moduleEnvVar.split(QLatin1Char(';'));

        QStringList qtSplit = qtComponents[0].split(QLatin1Char('='));

        if (qtSplit.size() == 2) {

            qtModules = qtSplit[1].split(QLatin1Char(','));

            if (qtComponents.size() == 2)

                qtSourceDir = qtComponents[1];

    } else {

        qtModuleDir = QDir::cleanPath(QFile::decodeName(qgetenv(moduleVar)));

        if (qtModuleDir.isEmpty()) {

            QSKIP("$QT_MODULE_TO_TEST is unset - nothing to test.  "

                  "Set QT_MODULE_TO_TEST to the absolute path of a Qt module to test.");

    if (m_compiler != QLatin1String("g++")) {

        const QString message = QLatin1String("Support for \"")

            + m_compiler + QLatin1String("\" is not implemented yet.");

        QSKIP(qPrintable(message));

    if (qgetenv("PATH").contains("teambuilder"))

        qWarning("This test might not work with teambuilder, consider switching it off.");

    if (!qt) {

        QString configFile = qtModuleDir + "/tests/global/global.cfg";

        if (!QFile(configFile).exists()) {

            QSKIP(

                  qPrintable(QString(

                      "%1 does not exist.  Create it if you want to run this test."

                  ).arg(configFile))

);

        QString workDir = qtModuleDir + QStringLiteral("/tests/global");

        modules = qt_tests_shared_global_get_modules(workDir, configFile);

        if (!modules.size())

            QSKIP("No modules found.");

        incPaths = qt_tests_shared_global_get_include_paths(workDir, modules);

    } else

        incPaths << QLatin1String("-I") + qtDir + QLatin1String("/include");

    QVERIFY2(incPaths.size() > 0, "Parse INCPATH failed.");

    m_compilerArguments = compilerArguments(m_compiler, incPaths);

    // Run compiler to obtain version information.

    QString output;

    QString errorMessage;

    QVERIFY2(compilerVersion(m_compiler, &output, &m_compilerVersion, &errorMessage), qPrintable(errorMessage));

    m_fileSuffix = fileSuffix(m_compiler, m_compilerVersion);

    QString message;

    QTextStream str(&message);

    str << "\nBinary  : " << m_appFilePath

        << "\nBuilt   : " << __DATE__

        << "\nQTDIR   : " << qgetenv("QTDIR")

        << '\n' << moduleVar << ": " << qtModuleDir

        << "\nqmake   : " << QStandardPaths::findExecutable(qmake) << '\n'

        << "\nCompiler: " << m_compiler << ' ' << m_compilerVersion.first << '.'

        << m_compilerVersion.second << '\n' <<  output << "\nArguments: ";

    for (int i = 0; i < m_compilerArguments.size(); ++i) {

        if (i)

            str << ' ';

        const bool needsQuote = m_compilerArguments.at(i).contains(QLatin1Char(' '));

        if (needsQuote)

            str << '"';

        str << m_compilerArguments.at(i);

        if (needsQuote)

            str << '"';

    str << "\n\nFile suffix: " << m_fileSuffix << "\n\n";

    qDebug().nospace()

#if QT_VERSION >= 0x050000

        .noquote()

#endif

        << message;

void tst_Bic::cleanupTestCase()

void tst_Bic::sizesAndVTables_data()

    if (m_fileSuffix.isEmpty())

        QSKIP("Test not implemented for this compiler/platform");

    if (m_fileSuffix == QLatin1String(noneSuchFileSuffix))

        QSKIP("No reference files found for this platform");

    QTest::addColumn<QString>("libName");

    QTest::addColumn<QString>("oldLib");

    QTest::addColumn<bool>("isPatchRelease");

    QStringList keys;

    if (qtModules.isEmpty())

        keys = modules.keys();

    else

        keys << QLatin1String("qt");

    int major = QT_VERSION_MAJOR;

    int minor = QT_VERSION_MINOR;

    int patch = QT_VERSION_PATCH;

    QFile qmakeConf(qtSourceDir.isEmpty() ? qtModuleDir : qtSourceDir + "/.qmake.conf");

    if (qmakeConf.open(QIODevice::ReadOnly)) {

        const QString contents = QString::fromUtf8(qmakeConf.readAll());

        qmakeConf.close();

        QRegularExpression versionRegExp("MODULE_VERSION\\s*=\\s*(\\d+)\\.(\\d+)\\.(\\d+)");

        QRegularExpressionMatch match = versionRegExp.match(contents);

        if (match.hasMatch()) {

            major = match.captured(1).toInt();

            minor = match.captured(2).toInt();

            patch = match.captured(3).toInt();

            qDebug() << "Detected module version major:" << major << "minor:" << minor << "patch:" << patch;

    if (minor == 0) {

        QSKIP("This is the first minor release in the major series, there is no binary compatibility reference data by definition.");

    for (int i = 0, end = keys.size(); i < end; i++) {

        QString key = keys.at(i);

        for (int i = 0; i <= minor; ++i) {

            if (i != minor || patch) {

#if QT_VERSION >= 0x060000

                QTest::newRow(key.toLatin1() + ":6." + QByteArray::number(i))

#else

                QTest::newRow(key.toLatin1() + ":5." + QByteArray::number(i))

#endif

                    << key

                    << (QString(qtSourceDir.isEmpty() ? qtModuleDir : qtSourceDir + "/tests/auto/bic/data/%1.")

                        + QString::number(major)

                        + QLatin1Char('.')

                        + QString::number(i)

                        + QLatin1String(".0.") + m_fileSuffix + QLatin1String(".txt"))

                    << (i == minor && patch);

#ifndef QT_NO_PROCESS

QBic::Info tst_Bic::getCurrentInfo(const QString &libName)

    QBic::Info &inf = cachedCurrentInfo[libName];

    if (!inf.classSizes.isEmpty())

        return inf;

    QTemporaryFile tmpQFile;

    if (!tmpQFile.open()) {

        qFatal() << "Could not open temporary file" << tmpQFile.fileName()

                 << "for writing" << tmpQFile.errorString();

        return {};

    QString tmpFileName = tmpQFile.fileName();

    QByteArray tmpFileContents;

    if (qtModules.isEmpty()) {

        tmpFileContents = "#include<" + libName.toLatin1() + "/" + libName.toLatin1() + ">\n";

    } else {

        for (auto &&x : qtModules)

            tmpFileContents += "#include<" + x.toLatin1() + "/" + x.toLatin1() + ">\n";

    tmpQFile.write(tmpFileContents);

    tmpQFile.flush();

    QStringList args = m_compilerArguments;

    args.append(tmpFileName);

    QProcess proc;

    proc.start(m_compiler, args, QIODevice::ReadOnly);

    if (!proc.waitForFinished(6000000)) {

        qWarning() << m_compiler << "didn't finish" << proc.errorString();

        return QBic::Info();

    if (proc.exitCode() != 0) {

        qWarning() << m_compiler << "returned with" << proc.exitCode();

        qDebug() << proc.readAllStandardError();

        return QBic::Info();

    QString errs = QString::fromLocal8Bit(proc.readAllStandardError().constData());

    if (!errs.isEmpty()) {

        qDebug() << "Arguments:" << args << "Warnings:" << errs;

        return QBic::Info();

    // See if we find the gcc output file, which seems to change

    // from release to release

    QDir dir;

    QStringList files = dir.entryList(QStringList() << "*.class");

    if (files.isEmpty()) {

        const QString message = QLatin1String("Could not locate the GCC output file in ")

            + QDir::toNativeSeparators(dir.absolutePath())

            + QLatin1String(", update this test");

        qFatal("%s", qPrintable(message));

        return QBic::Info();

    } else if (files.size() > 1) {

        const QString message = QLatin1String("Located more than one output file (")

            + files.join(QLatin1String(" ")) + QLatin1String(") in ")

            + QDir::toNativeSeparators(dir.absolutePath())

            + QLatin1String(", please clean up before running this test");

        qFatal("%s", qPrintable(message));

        return QBic::Info();

    QString resultFileName = files.first();

    inf = bic.parseFile(resultFileName);

    QFile::remove(resultFileName);

    tmpQFile.close();

    return inf;

#endif

void tst_Bic::sizesAndVTables()

#if !defined(Q_CC_GNU)

    QSKIP("Test not implemented for this compiler/platform");

#elif defined(QT_NO_PROCESS)

    QSKIP("This Qt build does not have QProcess support");

#else

    QFETCH(QString, libName);

    QFETCH(QString, oldLib);

    QFETCH(bool, isPatchRelease);

    bool isFailed = false;

    if (oldLib.isEmpty())

        QSKIP("No platform spec found for this platform/version.");

    const QString oldLibFileName = oldLib.arg(libName);

    if (!QFile::exists(oldLibFileName)) {

        const QString message = QLatin1String("No platform spec found for this platform/version - ")

            + QDir::toNativeSeparators(oldLibFileName) + QLatin1String(" not found.");

        QSKIP(qPrintable(message));

    const QBic::Info oldLibInfo = bic.parseFile(oldLibFileName);

    QVERIFY(!oldLibInfo.classVTables.isEmpty());

    const QBic::Info currentLibInfo = getCurrentInfo(libName);

    QVERIFY(!currentLibInfo.classVTables.isEmpty());

    const QBic::VTableDiff diff = bic.diffVTables(oldLibInfo, currentLibInfo);

    if (!diff.removedVTables.isEmpty()) {

        qWarning() << "VTables for the following classes were removed" << diff.removedVTables;

        isFailed = true;

    if (!diff.modifiedVTables.isEmpty()) {

        if (diff.modifiedVTables.size() != 1 ||

            strcmp(QTest::currentDataTag(), "4.4") != 0 ||

            diff.modifiedVTables.at(0).first != "QGraphicsProxyWidget") {

            for (const QStringPair &entry : diff.modifiedVTables)

                qWarning() << "modified VTable:\n    Old: " << entry.first

                           << "\n    New: " << entry.second;

            isFailed = true;

    if (isPatchRelease && !diff.addedVTables.isEmpty()) {

        qWarning() << "VTables for the following classes were added in a patch release:"

                   << diff.addedVTables;

        isFailed = true;

    if (isPatchRelease && !diff.reimpMethods.isEmpty()) {

        for (const QStringPair &entry : diff.reimpMethods)

            qWarning() << "reimplemented virtual in patch release:\n    Old: " << entry.first

                       << "\n    New: " << entry.second;

        isFailed = true;

    QBic::SizeDiff sizeDiff = bic.diffSizes(oldLibInfo, currentLibInfo);

    if (!sizeDiff.mismatch.isEmpty()) {

        for (QString className : sizeDiff.mismatch)

            qWarning() << "size mismatch for" << className

                       << "old" << oldLibInfo.classSizes.value(className)

                       << "new" << currentLibInfo.classSizes.value(className);

        isFailed = true;

#ifdef Q_CC_MINGW

/**

     * These symbols are from Windows' imm.h header, and is available

     * conditionally depending on the value of the WINVER define. We pull

     * them out since they're not relevant to the testing done.

*/

    sizeDiff.removed.removeAll(QLatin1String("tagIMECHARPOSITION"));

    sizeDiff.removed.removeAll(QLatin1String("tagRECONVERTSTRING"));

#endif

    if (!sizeDiff.removed.isEmpty()) {

        qWarning() << "the following classes were removed:" << sizeDiff.removed;

        isFailed = true;

    if (isPatchRelease && !sizeDiff.added.isEmpty()) {

        qWarning() << "the following classes were added in a patch release:" << sizeDiff.added;

        isFailed = true;

    if (isFailed)

        QFAIL("Test failed, read warnings above.");

#endif

int main(int argc, char *argv[])

    tst_Bic tc(argv[0]);

    QTEST_SET_MAIN_SOURCE_PATH

    return QTest::qExec(&tc, argc, argv);

#include "tst_bic.moc"