qabstracttestlogger.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtTest/private/qabstracttestlogger_p.h>
#include <QtTest/qtestassert.h>
#include <qbenchmark_p.h>
#include <qtestresult_p.h>
 
#include <QtCore/qbytearray.h>
#include <QtCore/qstring.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
 
#ifndef Q_OS_WIN
#include <unistd.h>
#endif
 
#ifdef Q_OS_ANDROID
#include <sys/stat.h>
#endif
 
QT_BEGIN_NAMESPACE
QAbstractTestLogger::QAbstractTestLogger(const char *filename)
{
    if (!filename) {
        stream = stdout;
        return;
    }
#if defined(_MSC_VER)
    if (::fopen_s(&stream, filename, "wt")) {
#else
    stream = ::fopen(filename, "wt");
    if (!stream) {
#endif
        fprintf(stderr, "Unable to open file for logging: %s\n", filename);
        ::exit(1);
    }
#ifdef Q_OS_ANDROID
    else {
        // Make sure output is world-readable on Android
        ::chmod(filename, 0666);
    }
#endif
}
 
QAbstractTestLogger::~QAbstractTestLogger()
{
    QTEST_ASSERT(stream);
    if (stream != stdout)
        fclose(stream);
    stream = nullptr;
}
 
bool QAbstractTestLogger::isRepeatSupported() const
{
    return false;
}
 
bool QAbstractTestLogger::isLoggingToStdout() const
{
    return stream == stdout;
}
 
void QAbstractTestLogger::filterUnprintable(char *str) const
{
    unsigned char *idx = reinterpret_cast<unsigned char *>(str);
    while (*idx) {
        if (((*idx < 0x20 && *idx != '\n' && *idx != '\t') || *idx == 0x7f))
            *idx = '?';
        ++idx;
    }
}
 
void QAbstractTestLogger::outputString(const char *msg)
{
    QTEST_ASSERT(stream);
    QTEST_ASSERT(msg);
 
    char *filtered = new char[strlen(msg) + 1];
    strcpy(filtered, msg);
    filterUnprintable(filtered);
 
    ::fputs(filtered, stream);
    ::fflush(stream);
 
    delete [] filtered;
}
 
void QAbstractTestLogger::startLogging()
{
}
 
void QAbstractTestLogger::stopLogging()
{
}
 
void QAbstractTestLogger::addBenchmarkResults(const QList<QBenchmarkResult> &result)
{
    for (const auto &m : result)
        addBenchmarkResult(m);
}
 
void QAbstractTestLogger::addMessage(QtMsgType type, const QMessageLogContext &context,
                                     const QString &message)
{
    QAbstractTestLogger::MessageTypes messageType = [=]() {
        switch (type) {
        case QtDebugMsg: return QAbstractTestLogger::QDebug;
        case QtInfoMsg: return QAbstractTestLogger::QInfo;
        case QtCriticalMsg: return QAbstractTestLogger::QCritical;
        case QtWarningMsg: return QAbstractTestLogger::QWarning;
        case QtFatalMsg: return QAbstractTestLogger::QFatal;
        }
        Q_UNREACHABLE_RETURN(QAbstractTestLogger::QFatal);
    }();
 
    QString formattedMessage = qFormatLogMessage(type, context, message);
 
    // Note that we explicitly ignore the file and line of the context here,
    // as that's what QTest::messageHandler used to do when calling the same
    // overload directly.
    addMessage(messageType, formattedMessage);
}
 
namespace
{
    constexpr int MAXSIZE = 1024 * 1024 * 2;
}
 
namespace QTest
{
 
int qt_asprintf(QTestCharBuffer *str, const char *format, ...)
{
    Q_ASSERT(str);
    int size = str->size();
    Q_ASSERT(size > 0);
 
    va_list ap;
    int res = 0;
 
    do {
        va_start(ap, format);
        res = qvsnprintf(str->data(), size, format, ap);
        va_end(ap);
        // vsnprintf() reliably '\0'-terminates
        Q_ASSERT(res < 0 || str->data()[res < size ? res : size - 1] == '\0');
        // Note, we're assuming that a result of -1 is always due to running out of space.
        if (res >= 0 && res < size) // Success
            break;
 
        // Buffer wasn't big enough, try again:
        size *= 2;
        // If too large or out of memory, take what we have:
    } while (size <= MAXSIZE && str->reset(size));
 
    return res;
}
 
}
 
namespace QTestPrivate
{
 
void generateTestIdentifier(QTestCharBuffer *identifier, int parts)
{
    const char *testObject = parts & TestObject ? QTestResult::currentTestObjectName() : "";
    const char *testFunction = parts & TestFunction ? (QTestResult::currentTestFunction() ? QTestResult::currentTestFunction() : "UnknownTestFunc") : "";
    const char *objectFunctionFiller = parts & TestObject && parts & (TestFunction | TestDataTag) ? "::" : "";
    const char *testFuctionStart = parts & TestFunction ? "(" : "";
    const char *testFuctionEnd = parts & TestFunction ? ")" : "";
 
    const char *dataTag = (parts & TestDataTag) && QTestResult::currentDataTag() ? QTestResult::currentDataTag() : "";
    const char *globalDataTag = (parts & TestDataTag) && QTestResult::currentGlobalDataTag() ? QTestResult::currentGlobalDataTag() : "";
    const char *tagFiller = (dataTag[0] && globalDataTag[0]) ? ":" : "";
 
    QTest::qt_asprintf(identifier, "%s%s%s%s%s%s%s%s",
        testObject, objectFunctionFiller, testFunction, testFuctionStart,
        globalDataTag, tagFiller, dataTag, testFuctionEnd);
}
 
// strcat() for QTestCharBuffer objects:
bool appendCharBuffer(QTestCharBuffer *accumulator, const QTestCharBuffer &more)
{
    const auto bufsize = [](const QTestCharBuffer &buf) -> int {
        const int max = buf.size();
        return max > 0 ? int(qstrnlen(buf.constData(), max)) : 0;
    };
    const int extra = bufsize(more);
    if (extra <= 0)
        return true; // Nothing to do, fatuous success
 
    const int oldsize = bufsize(*accumulator);
    const int newsize = oldsize + extra + 1; // 1 for final '\0'
    if (newsize > MAXSIZE || !accumulator->resize(newsize))
        return false; // too big or unable to grow
 
    char *tail = accumulator->data() + oldsize;
    memcpy(tail, more.constData(), extra);
    tail[extra] = '\0';
    return true;
}
 
}
 
QT_END_NAMESPACE