1 files changed, 204 insertions, 92 deletions

diff --git a/src/testlib/qplaintestlogger.cpp b/src/testlib/qplaintestlogger.cpp
index e716c38a73..58c7f6bf5b 100644
--- a/src/testlib/qplaintestlogger.cpp
+++ b/src/testlib/qplaintestlogger.cpp
@@ -10,18 +10,12 @@
 
 #include <QtCore/private/qlogging_p.h>
 
-#include <stdarg.h>
+#include <array>
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#ifdef min // windows.h without NOMINMAX is included by the benchmark headers.
-#  undef min
-#endif
-#ifdef max
-#  undef max
-#endif
-
 #include <QtCore/QByteArray>
 #include <QtCore/qmath.h>
 #include <QtCore/QLibraryInfo>
@@ -38,9 +32,78 @@ QT_BEGIN_NAMESPACE
 
 using namespace Qt::StringLiterals;
 
+namespace {
+static const char multiplePrefixes[] = "\0kMGTPE"; // kilo, mega, giga, tera, peta, exa
+static const char submultiplePrefixes[] = "afpnum"; // atto, femto, pico, nano, micro, milli
+
+template <int N> struct FixedBufString
+{
+    static constexpr size_t MaxSize = N;
+    size_t used = 0;
+    std::array<char, N + 2> buf;    // for the newline and terminating null
+    FixedBufString()
+    {
+        clear();
+    }
+    void clear()
+    {
+        used = 0;
+        buf[0] = '\0';
+    }
+
+    operator const char *() const
+    {
+        return buf.data();
+    }
+
+    void append(const char *text)
+    {
+        size_t len = qMin(strlen(text), MaxSize - used);
+        memcpy(buf.data() + used, text, len);
+        used += len;
+        buf[used] = '\0';
+    }
+
+    template <typename... Args> void appendf(const char *format, Args &&... args)
+    {
+        // vsnprintf includes the terminating null
+        used += qsnprintf(buf.data() + used, MaxSize - used + 1, format,
+                          std::forward<Args>(args)...);
+    }
+
+    template <int Power = 1000> void appendScaled(qreal value, const char *unit)
+    {
+        char prefix[2] = {};
+        qreal v = qAbs(value);
+        qint64 ratio;
+        if (v < 1 && Power == 1000) {
+            const char *prefixes = submultiplePrefixes;
+            ratio = qreal(std::atto::num) / std::atto::den;
+            while (value * ratio > 1000 && *prefixes) {
+                ++prefixes;
+                ratio *= 1000;
+            }
+            prefix[0] = *prefixes;
+        } else {
+            const char *prefixes = multiplePrefixes;
+            ratio = 1;
+            while (value > 1000 * ratio) {  // yes, even for binary
+                ++prefixes;
+                ratio *= Power;
+            }
+            prefix[0] = *prefixes;
+        }
+
+        // adjust the value by the ratio
+        value /= ratio;
+        appendf(", %.3g %s%s", value, prefix, unit);
+    }
+};
+} // unnamed namespace
+
 namespace QTest {
 
-    static const char *incidentType2String(QAbstractTestLogger::IncidentTypes type)
+    static const char *ptIncidentType2String(QAbstractTestLogger::IncidentTypes type)
     {
         switch (type) {
         case QAbstractTestLogger::Skip:
@@ -62,8 +125,7 @@ namespace QTest {
         case QAbstractTestLogger::BlacklistedXFail:
             return "BXFAIL ";
         }
-        Q_UNREACHABLE();
-        return nullptr;
+        Q_UNREACHABLE_RETURN(nullptr);
     }
 
     static const char *benchmarkResult2String()
@@ -71,7 +133,7 @@ namespace QTest {
         return "RESULT ";
     }
 
-    static const char *messageType2String(QAbstractTestLogger::MessageTypes type)
+    static const char *ptMessageType2String(QAbstractTestLogger::MessageTypes type)
     {
         switch (type) {
         case QAbstractTestLogger::QDebug:
@@ -89,8 +151,7 @@ namespace QTest {
         case QAbstractTestLogger::Warn:
             return "WARNING";
         }
-        Q_UNREACHABLE();
-        return nullptr;
+        Q_UNREACHABLE_RETURN(nullptr);
     }
 
     template <typename T>
@@ -111,19 +172,19 @@ namespace QTest {
     }
 
     // Pretty-prints a benchmark result using the given number of digits.
-    template <typename T> QString formatResult(T number, int significantDigits)
+    template <typename T> QByteArray formatResult(T number, int significantDigits)
     {
         if (number < T(0))
-            return u"NAN"_s;
+            return "NAN";
         if (number == T(0))
-            return u"0"_s;
+            return "0";
 
-        QString beforeDecimalPoint = QString::number(qint64(number), 'f', 0);
-        QString afterDecimalPoint = QString::number(number, 'f', 20);
-        afterDecimalPoint.remove(0, beforeDecimalPoint.length() + 1);
+        QByteArray beforeDecimalPoint = QByteArray::number(qint64(number), 'f', 0);
+        QByteArray afterDecimalPoint = QByteArray::number(number, 'f', 20);
+        afterDecimalPoint.remove(0, beforeDecimalPoint.size() + 1);
 
-        int beforeUse = qMin(beforeDecimalPoint.length(), significantDigits);
-        int beforeRemove = beforeDecimalPoint.length() - beforeUse;
+        int beforeUse = qMin(beforeDecimalPoint.size(), significantDigits);
+        int beforeRemove = beforeDecimalPoint.size() - beforeUse;
 
         // Replace insignificant digits before the decimal point with zeros.
         beforeDecimalPoint.chop(beforeRemove);
@@ -134,30 +195,30 @@ namespace QTest {
         int afterUse = significantDigits - beforeUse;
 
         // leading zeroes after the decimal point does not count towards the digit use.
-        if (beforeDecimalPoint == u'0' && !afterDecimalPoint.isEmpty()) {
+        if (beforeDecimalPoint == "0" && !afterDecimalPoint.isEmpty()) {
             ++afterUse;
 
             int i = 0;
-            while (i < afterDecimalPoint.length() && afterDecimalPoint.at(i) == u'0')
+            while (i < afterDecimalPoint.size() && afterDecimalPoint.at(i) == '0')
                 ++i;
 
             afterUse += i;
         }
 
-        int afterRemove = afterDecimalPoint.length() - afterUse;
+        int afterRemove = afterDecimalPoint.size() - afterUse;
         afterDecimalPoint.chop(afterRemove);
 
-        QChar separator = u',';
-        QChar decimalPoint = u'.';
+        char separator = ',';
+        char decimalPoint = '.';
 
         // insert thousands separators
-        int length = beforeDecimalPoint.length();
-        for (int i = beforeDecimalPoint.length() -1; i >= 1; --i) {
+        int length = beforeDecimalPoint.size();
+        for (int i = beforeDecimalPoint.size() -1; i >= 1; --i) {
             if ((length - i) % 3 == 0)
                 beforeDecimalPoint.insert(i, separator);
         }
 
-        QString print;
+        QByteArray print;
         print = beforeDecimalPoint;
         if (afterUse > 0)
             print.append(decimalPoint);
@@ -167,15 +228,6 @@ namespace QTest {
 
         return print;
     }
-
-    template <typename T>
-    int formatResult(char * buffer, int bufferSize, T number, int significantDigits)
-    {
-        QString result = formatResult(number, significantDigits);
-        int size = result.length();
-        qstrncpy(buffer, std::move(result).toLatin1().constData(), bufferSize);
-        return size;
-    }
 }
 
 /*! \internal
@@ -184,7 +236,7 @@ namespace QTest {
 
     QPlainTestLogger implements basic logging of test results.
 
-    The format is Qt-specific and aims to be be easy to read.
+    The format is Qt-specific and aims to be easy to read.
 */
 
 void QPlainTestLogger::outputMessage(const char *str)
@@ -242,60 +294,110 @@ void QPlainTestLogger::printMessage(MessageSource source, const char *type, cons
     outputMessage(messagePrefix.data());
 }
 
-void QPlainTestLogger::printBenchmarkResult(const QBenchmarkResult &result)
+void QPlainTestLogger::printBenchmarkResultsHeader(const QBenchmarkResult &result)
 {
-    const char *bmtag = QTest::benchmarkResult2String();
-
-    char buf1[1024];
-    qsnprintf(
-        buf1, sizeof(buf1), "%s: %s::%s",
-        bmtag,
-        QTestResult::currentTestObjectName(),
-        result.context.slotName.toLatin1().data());
-
-    char bufTag[1024];
-    bufTag[0] = 0;
-    QByteArray tag = result.context.tag.toLocal8Bit();
-    if (tag.isEmpty() == false) {
-        qsnprintf(bufTag, sizeof(bufTag), ":\"%s\"", tag.data());
-    }
-
-
-    char fillFormat[8];
-    int fillLength = 5;
-    qsnprintf(fillFormat, sizeof(fillFormat), ":\n%%%ds", fillLength);
-    char fill[1024];
-    qsnprintf(fill, sizeof(fill), fillFormat, "");
-
-    const char * unitText = QTest::benchmarkMetricUnit(result.metric);
+    FixedBufString<1022> buf;
+    buf.appendf("%s: %s::%s", QTest::benchmarkResult2String(),
+                QTestResult::currentTestObjectName(), result.context.slotName.toLatin1().data());
+
+    if (QByteArray tag = result.context.tag.toLocal8Bit(); !tag.isEmpty())
+        buf.appendf(":\"%s\":\n", tag.data());
+    else
+        buf.append(":\n");
+    outputMessage(buf);
+}
 
-    qreal valuePerIteration = qreal(result.value) / qreal(result.iterations);
-    char resultBuffer[100] = "";
-    QTest::formatResult(resultBuffer, 100, valuePerIteration, QTest::countSignificantDigits(result.value));
+void QPlainTestLogger::printBenchmarkResults(const QList<QBenchmarkResult> &results)
+{
+    using namespace std::chrono;
+    FixedBufString<1022> buf;
+    auto findResultFor = [&results](QTest::QBenchmarkMetric metric) -> std::optional<qreal> {
+        for (const QBenchmarkResult &result : results) {
+            if (result.measurement.metric == metric)
+                return result.measurement.value;
+        }
+        return std::nullopt;
+    };
+
+    // we need the execution time quite often, so find it first
+    qreal executionTime = 0;
+    if (auto ns = findResultFor(QTest::WalltimeNanoseconds))
+        executionTime = *ns / (1000 * 1000 * 1000);
+    else if (auto ms = findResultFor(QTest::WalltimeMilliseconds))
+        executionTime = *ms / 1000;
+
+    for (const QBenchmarkResult &result : results) {
+        buf.clear();
+
+        const char * unitText = QTest::benchmarkMetricUnit(result.measurement.metric);
+        int significantDigits = QTest::countSignificantDigits(result.measurement.value);
+        qreal valuePerIteration = qreal(result.measurement.value) / qreal(result.iterations);
+        buf.appendf("     %s %s%s", QTest::formatResult(valuePerIteration, significantDigits).constData(),
+                    unitText, result.setByMacro ? " per iteration" : "");
+
+        switch (result.measurement.metric) {
+        case QTest::BitsPerSecond:
+            // for bits/s, we'll use powers of 10 (1 Mbit/s = 1000 kbit/s = 1000000 bit/s)
+            buf.appendScaled<1000>(result.measurement.value, "bit/s");
+            break;
+        case QTest::BytesPerSecond:
+            // for B/s, we'll use powers of 2 (1 MB/s = 1024 kB/s = 1048576 B/s)
+            buf.appendScaled<1024>(result.measurement.value, "B/s");
+            break;
 
-    char buf2[1024];
-    qsnprintf(buf2, sizeof(buf2), "%s %s", resultBuffer, unitText);
+        case QTest::CPUCycles:
+        case QTest::RefCPUCycles:
+            if (!qIsNull(executionTime))
+                buf.appendScaled(result.measurement.value / executionTime, "Hz");
+            break;
 
-    char buf2_[1024];
-    QByteArray iterationText = " per iteration";
-    Q_ASSERT(result.iterations > 0);
-    qsnprintf(buf2_, sizeof(buf2_), "%s", iterationText.data());
+        case QTest::Instructions:
+            if (auto cycles = findResultFor(QTest::CPUCycles)) {
+                buf.appendf(", %.3f instr/cycle", result.measurement.value / *cycles);
+                break;
+            }
+            Q_FALLTHROUGH();
+
+        case QTest::InstructionReads:
+        case QTest::Events:
+        case QTest::BytesAllocated:
+        case QTest::CPUMigrations:
+        case QTest::BusCycles:
+        case QTest::StalledCycles:
+        case QTest::BranchInstructions:
+        case QTest::BranchMisses:
+        case QTest::CacheReferences:
+        case QTest::CacheReads:
+        case QTest::CacheWrites:
+        case QTest::CachePrefetches:
+        case QTest::CacheMisses:
+        case QTest::CacheReadMisses:
+        case QTest::CacheWriteMisses:
+        case QTest::CachePrefetchMisses:
+        case QTest::ContextSwitches:
+        case QTest::PageFaults:
+        case QTest::MinorPageFaults:
+        case QTest::MajorPageFaults:
+        case QTest::AlignmentFaults:
+        case QTest::EmulationFaults:
+            if (!qIsNull(executionTime))
+                buf.appendScaled(result.measurement.value / executionTime, "/sec");
+            break;
 
-    char buf3[1024];
-    Q_ASSERT(result.iterations > 0);
-    QTest::formatResult(resultBuffer, 100, result.value, QTest::countSignificantDigits(result.value));
-    qsnprintf(buf3, sizeof(buf3), " (total: %s, iterations: %d)", resultBuffer, result.iterations);
+        case QTest::FramesPerSecond:
+        case QTest::CPUTicks:
+        case QTest::WalltimeMilliseconds:
+        case QTest::WalltimeNanoseconds:
+            break;  // no additional information
+        }
 
-    char buf[1024];
+        Q_ASSERT(result.iterations > 0);
+        buf.appendf(" (total: %s, iterations: %d)\n",
+                    QTest::formatResult(result.measurement.value, significantDigits).constData(),
+                    result.iterations);
 
-    if (result.setByMacro) {
-        qsnprintf(buf, sizeof(buf), "%s%s%s%s%s%s\n", buf1, bufTag, fill, buf2, buf2_, buf3);
-    } else {
-        qsnprintf(buf, sizeof(buf), "%s%s%s%s\n", buf1, bufTag, fill, buf2);
+        outputMessage(buf);
     }
-
-    memcpy(buf, bmtag, strlen(bmtag));
-    outputMessage(buf);
 }
 
 QPlainTestLogger::QPlainTestLogger(const char *filename)
@@ -347,7 +449,7 @@ void QPlainTestLogger::stopLogging()
 void QPlainTestLogger::enterTestFunction(const char * /*function*/)
 {
     if (QTestLog::verboseLevel() >= 1)
-        printMessage(MessageSource::Other, QTest::messageType2String(Info), "entering");
+        printMessage(MessageSource::Other, QTest::ptMessageType2String(Info), "entering");
 }
 
 void QPlainTestLogger::leaveTestFunction()
@@ -362,16 +464,17 @@ void QPlainTestLogger::addIncident(IncidentTypes type, const char *description,
         && QTestLog::verboseLevel() < 0)
         return;
 
-    printMessage(MessageSource::Incident, QTest::incidentType2String(type), description, file, line);
+    printMessage(MessageSource::Incident, QTest::ptIncidentType2String(type), description, file, line);
 }
 
-void QPlainTestLogger::addBenchmarkResult(const QBenchmarkResult &result)
+void QPlainTestLogger::addBenchmarkResults(const QList<QBenchmarkResult> &results)
 {
     // suppress benchmark results in silent mode
-    if (QTestLog::verboseLevel() < 0)
+    if (QTestLog::verboseLevel() < 0 || results.isEmpty())
         return;
 
-    printBenchmarkResult(result);
+    printBenchmarkResultsHeader(results.first());
+    printBenchmarkResults(results);
 }
 
 void QPlainTestLogger::addMessage(QtMsgType type, const QMessageLogContext &context, const QString &message)
@@ -386,7 +489,16 @@ void QPlainTestLogger::addMessage(MessageTypes type, const QString &message,
     if (type != QFatal && QTestLog::verboseLevel() < 0)
         return;
 
-    printMessage(MessageSource::Other, QTest::messageType2String(type), qPrintable(message), file, line);
+    printMessage(MessageSource::Other, QTest::ptMessageType2String(type), qPrintable(message), file, line);
+}
+
+bool QPlainTestLogger::isRepeatSupported() const
+{
+    // The plain text logger creates unstructured reports. Such reports are not
+    // parser friendly, and are unlikely to be parsed by any test reporting
+    // tools. We can therefore allow repeated test runs with minimum risk that
+    // any parsers fails to handle repeated test names.
+    return true;
 }
 
 QT_END_NAMESPACE