Merge branch '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-1 into 4.6-integration

* '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-1:
  tst_selftest: parse benchlib results in XML format too
  tst_selftests: replace a line number with __LINE__ in XML too

1 files changed, 84 insertions, 11 deletions

diff --git a/tests/auto/selftests/tst_selftests.cpp b/tests/auto/selftests/tst_selftests.cpp
index 0ef000c..0be4e22 100644
--- a/tests/auto/selftests/tst_selftests.cpp
+++ b/tests/auto/selftests/tst_selftests.cpp
@@ -117,19 +117,26 @@ static QList<QByteArray> splitLines(QByteArray ba)
     ba.replace('\r', "");
     QList<QByteArray> out = ba.split('\n');
 
-    // Replace any ` file="..."' in XML with a generic location.
-    static const char marker[] = " file=\"";
+    // Replace any ` file="..."' or ` line="..."'  in XML with a generic location.
+    static const char *markers[][2] = {
+        { " file=\"", " file=\"__FILE__\"" },
+        { " line=\"", " line=\"__LINE__\"" }
+    };
+    static const int markerCount = sizeof markers / sizeof markers[0];
+
     for (int i = 0; i < out.size(); ++i) {
         QByteArray& line = out[i];
-        int index = line.indexOf(marker);
-        if (index == -1) {
-            continue;
-        }
-        int end = line.indexOf('"', index + sizeof(marker));
-        if (end == -1) {
-            continue;
+        for (int j = 0; j < markerCount; ++j) {
+            int index = line.indexOf(markers[j][0]);
+            if (index == -1) {
+                continue;
+            }
+            int end = line.indexOf('"', index + strlen(markers[j][0]) + 1);
+            if (end == -1) {
+                continue;
+            }
+            line.replace(index, end-index, markers[j][1]);
         }
-        line.replace(index, end-index, " file=\"__FILE__\"");
     }
 
     return out;
@@ -421,7 +428,7 @@ void tst_Selftests::doRunSubTest(QString const& subdir, QString const& logger, Q
                    Are we expecting this line to be a benchmark result?
                    If so, don't do a literal comparison, since results have some natural variance.
                 */
-                if (benchmark) {
+                if (benchmark || line.startsWith("<BenchmarkResult")) {
                     QString error;
 
                     BenchmarkResult actualResult = BenchmarkResult::parse(output, &error);
@@ -451,6 +458,22 @@ void tst_Selftests::runSubTest()
     doRunSubTest(subdir, logger, arguments);
 }
 
+// attribute must contain ="
+QString extractXmlAttribute(const QString &line, const char *attribute)
+{
+    int index = line.indexOf(attribute);
+    if (index == -1)
+        return QString();
+    int end = line.indexOf('"', index + strlen(attribute));
+    if (end == -1)
+        return QString();
+
+    QString result = line.mid(index + strlen(attribute), end - index - strlen(attribute));
+    if (result.isEmpty())
+        return ""; // ensure empty but not null
+    return result;
+}
+
 /* Parse line into the BenchmarkResult it represents. */
 BenchmarkResult BenchmarkResult::parse(QString const& line, QString* error)
 {
@@ -464,6 +487,56 @@ BenchmarkResult BenchmarkResult::parse(QString const& line, QString* error)
         return out;
     }
 
+    if (line.startsWith("<BenchmarkResult ")) {
+        // XML result
+        // format:
+        //   <BenchmarkResult metric="$unit" tag="$tag" value="$total" iterations="$iterations" />
+        if (!line.endsWith("/>")) {
+            if (error) *error = "unterminated XML";
+            return out;
+        }
+
+        QString unit = extractXmlAttribute(line, " metric=\"");
+        QString sTotal = extractXmlAttribute(line, " value=\"");
+        QString sIterations = extractXmlAttribute(line, " iterations=\"");
+        if (unit.isNull() || sTotal.isNull() || sIterations.isNull()) {
+            if (error) *error = "XML snippet did not contain all required values";
+            return out;
+        }
+
+        bool ok;
+#if QT_VERSION >= 0x040700
+        // Qt 4.7 uses floating point
+        double total = sTotal.toDouble(&ok);
+        if (!ok) {
+            if (error) *error = sTotal + " is not a valid number";
+            return out;
+        }
+        double iterations = sIterations.toDouble(&ok);
+        if (!ok) {
+            if (error) *error = sIterations + " is not a valid number";
+            return out;
+        }
+#else
+        qlonglong total = sTotal.toLongLong(&ok);
+        if (!ok) {
+            if (error) *error = sTotal + " is not a valid integer";
+            return out;
+        }
+        qlonglong iterations = sIterations.toLongLong(&ok);
+        if (!ok) {
+            if (error) *error = sIterations + " is not a valid integer";
+            return out;
+        }
+#endif
+
+        out.unit = unit;
+        out.total = total;
+        out.iterations = iterations;
+        return out;
+    }
+    // Text result
+
     /* This code avoids using a QRegExp because QRegExp might be broken. */
 
     /* Sample format: 4,000 msec per iteration (total: 4000, iterations: 1) */