From 16158e1132da292df6f911df0671c7bf71d145d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A5rten=20Nordheim?= Date: Tue, 21 May 2019 14:48:57 +0200 Subject: Win: qdiriterator bench: fix missing null-terminator issues It's not done by toWCharArray. This caused some issues as we were using API requiring a null-terminator. wcslen for instance was measuring the string as being millions of characters long, causing fairly quick crashes when appending. Change-Id: Iedaaf9f195be22a610543ab649da92a87cb71973 Reviewed-by: Edward Welbourne --- tests/benchmarks/corelib/io/qdiriterator/main.cpp | 24 +++++++++++----------- .../io/qdiriterator/qfilesystemiterator.cpp | 5 +++-- 2 files changed, 15 insertions(+), 14 deletions(-) (limited to 'tests/benchmarks') diff --git a/tests/benchmarks/corelib/io/qdiriterator/main.cpp b/tests/benchmarks/corelib/io/qdiriterator/main.cpp index e71daccf7d..eae752d99a 100644 --- a/tests/benchmarks/corelib/io/qdiriterator/main.cpp +++ b/tests/benchmarks/corelib/io/qdiriterator/main.cpp @@ -78,24 +78,22 @@ void tst_qdiriterator::data() } #ifdef Q_OS_WIN -static int posix_helper(const wchar_t *dirpath) +static int posix_helper(const wchar_t *dirpath, size_t length) { int count = 0; HANDLE hSearch; WIN32_FIND_DATA fd; - const size_t origDirPathLength = wcslen(dirpath); - wchar_t appendedPath[MAX_PATH]; - wcscpy(appendedPath, dirpath); - wcscat(appendedPath, L"\\*"); + Q_ASSERT(MAX_PATH > length + 3); + wcsncpy(appendedPath, dirpath, length); + wcscpy(appendedPath + length, L"\\*"); #ifndef Q_OS_WINRT hSearch = FindFirstFile(appendedPath, &fd); #else hSearch = FindFirstFileEx(appendedPath, FindExInfoStandard, &fd, FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH); #endif - appendedPath[origDirPathLength] = 0; if (hSearch == INVALID_HANDLE_VALUE) { qWarning("FindFirstFile failed"); @@ -107,10 +105,12 @@ static int posix_helper(const wchar_t *dirpath) !(fd.cFileName[0] == L'.' && fd.cFileName[1] == L'.' && fd.cFileName[2] == 0)) { if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { - wcscat(appendedPath, L"\\"); - wcscat(appendedPath, fd.cFileName); - count += posix_helper(appendedPath); - appendedPath[origDirPathLength] = 0; + // newLength will "point" to where we put a * earlier, so we overwrite that. + size_t newLength = length + 1; // "+ 1" for directory separator + Q_ASSERT(newLength + wcslen(fd.cFileName) + 1 < MAX_PATH); // "+ 1" for null-terminator + wcscpy(appendedPath + newLength, fd.cFileName); + newLength += wcslen(fd.cFileName); + count += posix_helper(appendedPath, newLength); } else { ++count; @@ -164,8 +164,8 @@ void tst_qdiriterator::posix() QBENCHMARK { #ifdef Q_OS_WIN wchar_t wPath[MAX_PATH]; - path.toWCharArray(wPath); - count = posix_helper(wPath); + const int end = path.toWCharArray(wPath); + count = posix_helper(wPath, end); #else count = posix_helper(dirpath.constData()); #endif diff --git a/tests/benchmarks/corelib/io/qdiriterator/qfilesystemiterator.cpp b/tests/benchmarks/corelib/io/qdiriterator/qfilesystemiterator.cpp index d68264b78f..6ee8b4e93b 100644 --- a/tests/benchmarks/corelib/io/qdiriterator/qfilesystemiterator.cpp +++ b/tests/benchmarks/corelib/io/qdiriterator/qfilesystemiterator.cpp @@ -218,8 +218,9 @@ void QFileSystemIteratorPrivate::pushSubDirectory(const QByteArray &path) #ifdef Q_OS_WIN wchar_t szSearchPath[MAX_PATH]; - QString::fromLatin1(path).toWCharArray(szSearchPath); - wcscat(szSearchPath, L"\\*"); + const int end = QString::fromLatin1(path + "\\*").toWCharArray(szSearchPath); + Q_ASSERT(end < MAX_PATH); + szSearchPath[end] = L'\0'; #ifndef Q_OS_WINRT HANDLE dir = FindFirstFile(szSearchPath, &m_fileSearchResult); #else -- cgit v1.2.3 From a9aa206b7b8ac4e69f8c46233b4080e00e845ff5 Mon Sep 17 00:00:00 2001 From: Edward Welbourne Date: Mon, 27 May 2019 19:13:54 +0200 Subject: Move text-related code out of corelib/tools/ to corelib/text/ This includes byte array, string, char, unicode, locale, collation and regular expressions. Change-Id: I8b125fa52c8c513eb57a0f1298b91910e5a0d786 Reviewed-by: Volker Hilsheimer --- tests/benchmarks/corelib/corelib.pro | 1 + tests/benchmarks/corelib/text/qbytearray/main.cpp | 264 +++++++++ .../corelib/text/qbytearray/qbytearray.pro | 7 + tests/benchmarks/corelib/text/qchar/main.cpp | 136 +++++ tests/benchmarks/corelib/text/qchar/qchar.pro | 3 + tests/benchmarks/corelib/text/qlocale/main.cpp | 70 +++ tests/benchmarks/corelib/text/qlocale/qlocale.pro | 4 + tests/benchmarks/corelib/text/qregexp/main.cpp | 615 +++++++++++++++++++++ tests/benchmarks/corelib/text/qregexp/qregexp.pro | 20 + tests/benchmarks/corelib/text/qregexp/qregexp.qrc | 6 + tests/benchmarks/corelib/text/qstring/main.cpp | 193 +++++++ tests/benchmarks/corelib/text/qstring/qstring.pro | 5 + .../corelib/text/qstringbuilder/main.cpp | 420 ++++++++++++++ .../corelib/text/qstringbuilder/qstringbuilder.pro | 11 + .../benchmarks/corelib/text/qstringlist/.gitignore | 1 + tests/benchmarks/corelib/text/qstringlist/main.cpp | 201 +++++++ .../corelib/text/qstringlist/qstringlist.pro | 5 + tests/benchmarks/corelib/text/text.pro | 10 + tests/benchmarks/corelib/tools/qbytearray/main.cpp | 264 --------- .../corelib/tools/qbytearray/qbytearray.pro | 7 - tests/benchmarks/corelib/tools/qchar/main.cpp | 136 ----- tests/benchmarks/corelib/tools/qchar/qchar.pro | 3 - .../corelib/tools/qhash/paths_small_data.txt | 56 +- tests/benchmarks/corelib/tools/qlocale/main.cpp | 70 --- tests/benchmarks/corelib/tools/qlocale/qlocale.pro | 4 - tests/benchmarks/corelib/tools/qregexp/main.cpp | 615 --------------------- tests/benchmarks/corelib/tools/qregexp/qregexp.pro | 20 - tests/benchmarks/corelib/tools/qregexp/qregexp.qrc | 6 - tests/benchmarks/corelib/tools/qstring/main.cpp | 193 ------- tests/benchmarks/corelib/tools/qstring/qstring.pro | 5 - .../corelib/tools/qstringbuilder/main.cpp | 420 -------------- .../tools/qstringbuilder/qstringbuilder.pro | 11 - .../corelib/tools/qstringlist/.gitignore | 1 - .../benchmarks/corelib/tools/qstringlist/main.cpp | 201 ------- .../corelib/tools/qstringlist/qstringlist.pro | 5 - tests/benchmarks/corelib/tools/tools.pro | 7 - 36 files changed, 2002 insertions(+), 1994 deletions(-) create mode 100644 tests/benchmarks/corelib/text/qbytearray/main.cpp create mode 100644 tests/benchmarks/corelib/text/qbytearray/qbytearray.pro create mode 100644 tests/benchmarks/corelib/text/qchar/main.cpp create mode 100644 tests/benchmarks/corelib/text/qchar/qchar.pro create mode 100644 tests/benchmarks/corelib/text/qlocale/main.cpp create mode 100644 tests/benchmarks/corelib/text/qlocale/qlocale.pro create mode 100644 tests/benchmarks/corelib/text/qregexp/main.cpp create mode 100644 tests/benchmarks/corelib/text/qregexp/qregexp.pro create mode 100644 tests/benchmarks/corelib/text/qregexp/qregexp.qrc create mode 100644 tests/benchmarks/corelib/text/qstring/main.cpp create mode 100644 tests/benchmarks/corelib/text/qstring/qstring.pro create mode 100644 tests/benchmarks/corelib/text/qstringbuilder/main.cpp create mode 100644 tests/benchmarks/corelib/text/qstringbuilder/qstringbuilder.pro create mode 100644 tests/benchmarks/corelib/text/qstringlist/.gitignore create mode 100644 tests/benchmarks/corelib/text/qstringlist/main.cpp create mode 100644 tests/benchmarks/corelib/text/qstringlist/qstringlist.pro create mode 100644 tests/benchmarks/corelib/text/text.pro delete mode 100644 tests/benchmarks/corelib/tools/qbytearray/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qbytearray/qbytearray.pro delete mode 100644 tests/benchmarks/corelib/tools/qchar/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qchar/qchar.pro delete mode 100644 tests/benchmarks/corelib/tools/qlocale/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qlocale/qlocale.pro delete mode 100644 tests/benchmarks/corelib/tools/qregexp/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qregexp/qregexp.pro delete mode 100644 tests/benchmarks/corelib/tools/qregexp/qregexp.qrc delete mode 100644 tests/benchmarks/corelib/tools/qstring/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qstring/qstring.pro delete mode 100644 tests/benchmarks/corelib/tools/qstringbuilder/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qstringbuilder/qstringbuilder.pro delete mode 100644 tests/benchmarks/corelib/tools/qstringlist/.gitignore delete mode 100644 tests/benchmarks/corelib/tools/qstringlist/main.cpp delete mode 100644 tests/benchmarks/corelib/tools/qstringlist/qstringlist.pro (limited to 'tests/benchmarks') diff --git a/tests/benchmarks/corelib/corelib.pro b/tests/benchmarks/corelib/corelib.pro index 99af4c138f..010abd7751 100644 --- a/tests/benchmarks/corelib/corelib.pro +++ b/tests/benchmarks/corelib/corelib.pro @@ -4,6 +4,7 @@ SUBDIRS = \ json \ mimetypes \ kernel \ + text \ thread \ time \ tools \ diff --git a/tests/benchmarks/corelib/text/qbytearray/main.cpp b/tests/benchmarks/corelib/text/qbytearray/main.cpp new file mode 100644 index 0000000000..e421e7436b --- /dev/null +++ b/tests/benchmarks/corelib/text/qbytearray/main.cpp @@ -0,0 +1,264 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2016 Intel Corporation. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#include +#include +#include +#include + +#include + + +class tst_qbytearray : public QObject +{ + Q_OBJECT + QByteArray sourcecode; +private slots: + void initTestCase(); + void append(); + void append_data(); + + void latin1Uppercasing_qt54(); + void latin1Uppercasing_xlate(); + void latin1Uppercasing_xlate_checked(); + void latin1Uppercasing_category(); + void latin1Uppercasing_bitcheck(); +}; + +void tst_qbytearray::initTestCase() +{ + QFile self(QFINDTESTDATA("main.cpp")); + QVERIFY(self.open(QIODevice::ReadOnly)); + sourcecode = self.readAll(); +} + +void tst_qbytearray::append_data() +{ + QTest::addColumn("size"); + QTest::newRow("1") << int(1); + QTest::newRow("10") << int(10); + QTest::newRow("100") << int(100); + QTest::newRow("1000") << int(1000); + QTest::newRow("10000") << int(10000); + QTest::newRow("100000") << int(100000); + QTest::newRow("1000000") << int(1000000); + QTest::newRow("10000000") << int(10000000); + QTest::newRow("100000000") << int(100000000); +} + +void tst_qbytearray::append() +{ + QFETCH(int, size); + + QByteArray ba; + QBENCHMARK { + QByteArray ba2(size, 'x'); + ba.append(ba2); + ba.clear(); + } +} + +void tst_qbytearray::latin1Uppercasing_qt54() +{ + QByteArray s = sourcecode; + s.detach(); + + // the following was copied from qbytearray.cpp (except for the QBENCHMARK macro): + uchar *p_orig = reinterpret_cast(s.data()); + uchar *e = reinterpret_cast(s.end()); + + QBENCHMARK { + uchar *p = p_orig; + if (p) { + while (p != e) { + *p = QChar::toLower((ushort)*p); + p++; + } + } + } +} + + +/* +#!/usr/bin/perl -l +use feature "unicode_strings" +for (0..255) { + $up = uc(chr($_)); + $up = chr($_) if ord($up) > 0x100 || length $up > 1; + printf "0x%02x,", ord($up); + print "" if ($_ & 0xf) == 0xf; +} +*/ +static const uchar uppercased[256] = { + 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f, + 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f, + 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f, + 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f, + 0x60,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f, + 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x7b,0x7c,0x7d,0x7e,0x7f, + 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f, + 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f, + 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf, + 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf, + 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf, + 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf, + 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf, + 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xf7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xff +}; +void tst_qbytearray::latin1Uppercasing_xlate() +{ + QByteArray output = sourcecode; + output.detach(); + char *dst_orig = output.data(); + const char *src_orig = sourcecode.constBegin(); + const char *end = sourcecode.constEnd(); + QBENCHMARK { + char *dst = dst_orig; + for (const char *src = src_orig; src != end; ++src, ++dst) + *dst = uppercased[uchar(*src)]; + } +} + +void tst_qbytearray::latin1Uppercasing_xlate_checked() +{ + QByteArray output = sourcecode; + output.detach(); + char *dst_orig = output.data(); + const char *src_orig = sourcecode.constBegin(); + const char *end = sourcecode.constEnd(); + QBENCHMARK { + char *dst = dst_orig; + for (const char *src = src_orig; src != end; ++src, ++dst) { + uchar ch = uchar(*src); + uchar converted = uppercased[ch]; + if (ch != converted) + *dst = converted; + } + } +} + +/* +#!/bin/perl -l +use feature "unicode_strings"; +sub categorize($) { + # 'ß' and 'ÿ' are lowercase, but we cannot uppercase them + return 0 if $_[0] == 0xDF || $_[0] == 0xFF; + $ch = chr($_[0]); + return 2 if uc($ch) ne $ch; + return 1 if lc($ch) ne $ch; + return 0; +} +for (0..255) { + printf "%d,", categorize($_); + print "" if ($_ & 0xf) == 0xf; +} +*/ +static const char categories[256] = { + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, + 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,0 +}; + +void tst_qbytearray::latin1Uppercasing_category() +{ + QByteArray output = sourcecode; + output.detach(); + char *dst_orig = output.data(); + const char *src_orig = sourcecode.constBegin(); + const char *end = sourcecode.constEnd(); + QBENCHMARK { + char *dst = dst_orig; + for (const char *src = src_orig; src != end; ++src, ++dst) + *dst = categories[uchar(*src)] == 1 ? *src & ~0x20 : *src; + } +} + +/* +#!/bin/perl -l +use feature "unicode_strings"; +sub categorize($) { + # 'ß' and 'ÿ' are lowercase, but we cannot uppercase them + return 0 if $_[0] == 0xDF || $_[0] == 0xFF; + $ch = chr($_[0]); + return 2 if uc($ch) ne $ch; + return 1 if lc($ch) ne $ch; + return 0; +} +for $row (0..7) { + $val = 0; + for $col (0..31) { + $val |= (1<<$col) + if categorize($row * 31 + $col) == 2; + } + printf "0x%08x,", $val; +} +*/ + +static const quint32 shouldUppercase[8] = { + 0x00000000,0x00000000,0x00000000,0x3ffffff0,0x00000000,0x04000000,0x00000000,0xbfffff80 +}; + +static bool bittest(const quint32 *data, uchar bit) +{ + static const unsigned bitsperelem = sizeof(*data) * CHAR_BIT; + return data[bit / bitsperelem] & (1 << (bit & (bitsperelem - 1))); +} + +void tst_qbytearray::latin1Uppercasing_bitcheck() +{ + QByteArray output = sourcecode; + output.detach(); + char *dst_orig = output.data(); + const char *src_orig = sourcecode.constBegin(); + const char *end = sourcecode.constEnd(); + QBENCHMARK { + char *dst = dst_orig; + for (const char *src = src_orig; src != end; ++src, ++dst) + *dst = bittest(shouldUppercase, *src) ? uchar(*src) & ~0x20 : uchar(*src); + } +} + + +QTEST_MAIN(tst_qbytearray) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qbytearray/qbytearray.pro b/tests/benchmarks/corelib/text/qbytearray/qbytearray.pro new file mode 100644 index 0000000000..cf28b0247f --- /dev/null +++ b/tests/benchmarks/corelib/text/qbytearray/qbytearray.pro @@ -0,0 +1,7 @@ +TEMPLATE = app +TARGET = tst_bench_qbytearray + +QT = core testlib + +TESTDATA += main.cpp +SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/text/qchar/main.cpp b/tests/benchmarks/corelib/text/qchar/main.cpp new file mode 100644 index 0000000000..4dcf86786d --- /dev/null +++ b/tests/benchmarks/corelib/text/qchar/main.cpp @@ -0,0 +1,136 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#include +#include + +class tst_QChar: public QObject +{ + Q_OBJECT +private slots: + void isUpper_data(); + void isUpper(); + void isLower_data(); + void isLower(); + void isLetter_data(); + void isLetter(); + void isDigit_data(); + void isDigit(); + void isLetterOrNumber_data(); + void isLetterOrNumber(); + void isSpace_data(); + void isSpace(); +}; + +void tst_QChar::isUpper_data() +{ + QTest::addColumn("c"); + + QTest::newRow("k") << QChar('k'); + QTest::newRow("K") << QChar('K'); + QTest::newRow("5") << QChar('5'); + QTest::newRow("\\0") << QChar(); + QTest::newRow("space") << QChar(' '); + QTest::newRow("\\u3C20") << QChar(0x3C20); +} + +void tst_QChar::isUpper() +{ + QFETCH(QChar, c); + QBENCHMARK { + c.isUpper(); + } +} + +void tst_QChar::isLower_data() +{ + isUpper_data(); +} + +void tst_QChar::isLower() +{ + QFETCH(QChar, c); + QBENCHMARK { + c.isLower(); + } +} + +void tst_QChar::isLetter_data() +{ + isUpper_data(); +} + +void tst_QChar::isLetter() +{ + QFETCH(QChar, c); + QBENCHMARK { + c.isLetter(); + } +} + +void tst_QChar::isDigit_data() +{ + isUpper_data(); +} + +void tst_QChar::isDigit() +{ + QFETCH(QChar, c); + QBENCHMARK { + c.isDigit(); + } +} + +void tst_QChar::isLetterOrNumber_data() +{ + isUpper_data(); +} + +void tst_QChar::isLetterOrNumber() +{ + QFETCH(QChar, c); + QBENCHMARK { + c.isLetterOrNumber(); + } +} + +void tst_QChar::isSpace_data() +{ + isUpper_data(); +} + +void tst_QChar::isSpace() +{ + QFETCH(QChar, c); + QBENCHMARK { + c.isSpace(); + } +} + +QTEST_MAIN(tst_QChar) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qchar/qchar.pro b/tests/benchmarks/corelib/text/qchar/qchar.pro new file mode 100644 index 0000000000..80a9861f48 --- /dev/null +++ b/tests/benchmarks/corelib/text/qchar/qchar.pro @@ -0,0 +1,3 @@ +TARGET = tst_bench_qchar +QT = core testlib +SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/text/qlocale/main.cpp b/tests/benchmarks/corelib/text/qlocale/main.cpp new file mode 100644 index 0000000000..38d94af143 --- /dev/null +++ b/tests/benchmarks/corelib/text/qlocale/main.cpp @@ -0,0 +1,70 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include + +class tst_QLocale : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + void toUpper_QLocale_1(); + void toUpper_QLocale_2(); + void toUpper_QString(); +}; + +static QString data() +{ + return QStringLiteral("/qt-5/qtbase/tests/benchmarks/corelib/tools/qlocale"); +} + +#define LOOP(s) for (int i = 0; i < 5000; ++i) { s; } + +void tst_QLocale::toUpper_QLocale_1() +{ + QString s = data(); + QBENCHMARK { LOOP(QLocale().toUpper(s)) } +} + +void tst_QLocale::toUpper_QLocale_2() +{ + QString s = data(); + QLocale l; + QBENCHMARK { LOOP(l.toUpper(s)) } +} + +void tst_QLocale::toUpper_QString() +{ + QString s = data(); + QBENCHMARK { LOOP(s.toUpper()) } +} + +QTEST_MAIN(tst_QLocale) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qlocale/qlocale.pro b/tests/benchmarks/corelib/text/qlocale/qlocale.pro new file mode 100644 index 0000000000..e56bbe0341 --- /dev/null +++ b/tests/benchmarks/corelib/text/qlocale/qlocale.pro @@ -0,0 +1,4 @@ +TARGET = tst_bench_qlocale +QT = core testlib + +SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/text/qregexp/main.cpp b/tests/benchmarks/corelib/text/qregexp/main.cpp new file mode 100644 index 0000000000..798b23f2b0 --- /dev/null +++ b/tests/benchmarks/corelib/text/qregexp/main.cpp @@ -0,0 +1,615 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include +#include +#include + +#include +#ifdef HAVE_BOOST +#include +#endif + +#ifdef HAVE_JSC +#include +#include "pcre/pcre.h" +#endif +#define ZLIB_VERSION "1.2.3.4" + +class tst_qregexp : public QObject +{ + Q_OBJECT +public: + tst_qregexp(); +private slots: + void escape_old(); + void escape_old_data() { escape_data(); } + void escape_new1(); + void escape_new1_data() { escape_data(); } + void escape_new2(); + void escape_new2_data() { escape_data(); } + void escape_new3(); + void escape_new3_data() { escape_data(); } + void escape_new4(); + void escape_new4_data() { escape_data(); } +/* + JSC outperforms everything. + Boost is less impressive then expected. + */ + void simpleFind1(); + void rangeReplace1(); + void matchReplace1(); + + void simpleFind2(); + void rangeReplace2(); + void matchReplace2(); + + void simpleFindJSC(); + void rangeReplaceJSC(); + void matchReplaceJSC(); + + void simpleFindBoost(); + void rangeReplaceBoost(); + void matchReplaceBoost(); + +/* those apply an (incorrect) regexp on entire source + (this main.cpp). JSC appears to handle this + (ab)use case best. QRegExp performs extremly bad. + */ + void horribleWrongReplace1(); + void horribleReplace1(); + void horribleReplace2(); + void horribleWrongReplace2(); + void horribleWrongReplaceJSC(); + void horribleReplaceJSC(); + void horribleWrongReplaceBoost(); + void horribleReplaceBoost(); +private: + QString str1; + QString str2; + void escape_data(); +}; + +tst_qregexp::tst_qregexp() + :QObject() + ,str1("We are all happy monkeys") +{ + QFile f(":/main.cpp"); + f.open(QFile::ReadOnly); + str2=f.readAll(); +} + +static void verify(const QString "ed, const QString &expected) +{ + if (quoted != expected) + qDebug() << "ERROR:" << quoted << expected; +} + +void tst_qregexp::escape_data() +{ + QTest::addColumn("pattern"); + QTest::addColumn("expected"); + + QTest::newRow("escape 0") << "Hello world" << "Hello world"; + QTest::newRow("escape 1") << "(Hello world)" << "\\(Hello world\\)"; + { + QString s; + for (int i = 0; i < 10; ++i) + s += "(escape)"; + QTest::newRow("escape 10") << s << QRegExp::escape(s); + } + { + QString s; + for (int i = 0; i < 100; ++i) + s += "(escape)"; + QTest::newRow("escape 100") << s << QRegExp::escape(s); + } +} + +void tst_qregexp::escape_old() +{ + QFETCH(QString, pattern); + QFETCH(QString, expected); + + QBENCHMARK { + static const char meta[] = "$()*+.?[\\]^{|}"; + QString quoted = pattern; + int i = 0; + + while (i < quoted.length()) { + if (strchr(meta, quoted.at(i).toLatin1()) != 0) + quoted.insert(i++, QLatin1Char('\\')); + ++i; + } + + verify(quoted, expected); + } +} + +void tst_qregexp::escape_new1() +{ + QFETCH(QString, pattern); + QFETCH(QString, expected); + + QBENCHMARK { + QString quoted; + const int count = pattern.count(); + quoted.reserve(count * 2); + const QLatin1Char backslash('\\'); + for (int i = 0; i < count; i++) { + switch (pattern.at(i).toLatin1()) { + case '$': + case '(': + case ')': + case '*': + case '+': + case '.': + case '?': + case '[': + case '\\': + case ']': + case '^': + case '{': + case '|': + case '}': + quoted.append(backslash); + } + quoted.append(pattern.at(i)); + } + verify(quoted, expected); + } +} + +void tst_qregexp::escape_new2() +{ + QFETCH(QString, pattern); + QFETCH(QString, expected); + + QBENCHMARK { + int count = pattern.count(); + const QLatin1Char backslash('\\'); + QString quoted(count * 2, backslash); + const QChar *patternData = pattern.data(); + QChar *quotedData = quoted.data(); + int escaped = 0; + for ( ; --count >= 0; ++patternData) { + const QChar c = *patternData; + switch (c.unicode()) { + case '$': + case '(': + case ')': + case '*': + case '+': + case '.': + case '?': + case '[': + case '\\': + case ']': + case '^': + case '{': + case '|': + case '}': + ++escaped; + ++quotedData; + } + *quotedData = c; + ++quotedData; + } + quoted.resize(pattern.size() + escaped); + + verify(quoted, expected); + } +} + +void tst_qregexp::escape_new3() +{ + QFETCH(QString, pattern); + QFETCH(QString, expected); + + QBENCHMARK { + QString quoted; + const int count = pattern.count(); + quoted.reserve(count * 2); + const QLatin1Char backslash('\\'); + for (int i = 0; i < count; i++) { + switch (pattern.at(i).toLatin1()) { + case '$': + case '(': + case ')': + case '*': + case '+': + case '.': + case '?': + case '[': + case '\\': + case ']': + case '^': + case '{': + case '|': + case '}': + quoted += backslash; + } + quoted += pattern.at(i); + } + + verify(quoted, expected); + } +} + + +static inline bool needsEscaping(int c) +{ + switch (c) { + case '$': + case '(': + case ')': + case '*': + case '+': + case '.': + case '?': + case '[': + case '\\': + case ']': + case '^': + case '{': + case '|': + case '}': + return true; + } + return false; +} + +void tst_qregexp::escape_new4() +{ + QFETCH(QString, pattern); + QFETCH(QString, expected); + + QBENCHMARK { + const int n = pattern.size(); + const QChar *patternData = pattern.data(); + // try to prevent copy if no escape is needed + int i = 0; + for (int i = 0; i != n; ++i) { + const QChar c = patternData[i]; + if (needsEscaping(c.unicode())) + break; + } + if (i == n) { + verify(pattern, expected); + // no escaping needed, "return pattern" should be done here. + return; + } + const QLatin1Char backslash('\\'); + QString quoted(n * 2, backslash); + QChar *quotedData = quoted.data(); + for (int j = 0; j != i; ++j) + *quotedData++ = *patternData++; + int escaped = 0; + for (; i != n; ++i) { + const QChar c = *patternData; + if (needsEscaping(c.unicode())) { + ++escaped; + ++quotedData; + } + *quotedData = c; + ++quotedData; + ++patternData; + } + quoted.resize(n + escaped); + verify(quoted, expected); + // "return quoted" + } +} + + +void tst_qregexp::simpleFind1() +{ + int roff; + QRegExp rx("happy"); + rx.setPatternSyntax(QRegExp::RegExp); + QBENCHMARK{ + roff = rx.indexIn(str1); + } + QCOMPARE(roff, 11); +} + +void tst_qregexp::rangeReplace1() +{ + QString r; + QRegExp rx("[a-f]"); + rx.setPatternSyntax(QRegExp::RegExp); + QBENCHMARK{ + r = QString(str1).replace(rx, "-"); + } + QCOMPARE(r, QString("W- -r- -ll h-ppy monk-ys")); +} + +void tst_qregexp::matchReplace1() +{ + QString r; + QRegExp rx("[^a-f]*([a-f]+)[^a-f]*"); + rx.setPatternSyntax(QRegExp::RegExp); + QBENCHMARK{ + r = QString(str1).replace(rx, "\\1"); + } + QCOMPARE(r, QString("eaeaae")); +} + +void tst_qregexp::horribleWrongReplace1() +{ + QString r; + QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*"); + rx.setPatternSyntax(QRegExp::RegExp); + QBENCHMARK{ + r = QString(str2).replace(rx, "\\1.\\2.\\3"); + } + QCOMPARE(r, str2); +} + +void tst_qregexp::horribleReplace1() +{ + QString r; + QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*"); + rx.setPatternSyntax(QRegExp::RegExp); + QBENCHMARK{ + r = QString(str2).replace(rx, "\\1.\\2.\\3"); + } + QCOMPARE(r, QString("1.2.3")); +} + + +void tst_qregexp::simpleFind2() +{ + int roff; + QRegExp rx("happy"); + rx.setPatternSyntax(QRegExp::RegExp2); + QBENCHMARK{ + roff = rx.indexIn(str1); + } + QCOMPARE(roff, 11); +} + +void tst_qregexp::rangeReplace2() +{ + QString r; + QRegExp rx("[a-f]"); + rx.setPatternSyntax(QRegExp::RegExp2); + QBENCHMARK{ + r = QString(str1).replace(rx, "-"); + } + QCOMPARE(r, QString("W- -r- -ll h-ppy monk-ys")); +} + +void tst_qregexp::matchReplace2() +{ + QString r; + QRegExp rx("[^a-f]*([a-f]+)[^a-f]*"); + rx.setPatternSyntax(QRegExp::RegExp2); + QBENCHMARK{ + r = QString(str1).replace(rx, "\\1"); + } + QCOMPARE(r, QString("eaeaae")); +} + +void tst_qregexp::horribleWrongReplace2() +{ + QString r; + QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*"); + rx.setPatternSyntax(QRegExp::RegExp2); + QBENCHMARK{ + r = QString(str2).replace(rx, "\\1.\\2.\\3"); + } + QCOMPARE(r, str2); +} + +void tst_qregexp::horribleReplace2() +{ + QString r; + QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*"); + rx.setPatternSyntax(QRegExp::RegExp2); + QBENCHMARK{ + r = QString(str2).replace(rx, "\\1.\\2.\\3"); + } + QCOMPARE(r, QString("1.2.3")); +} +void tst_qregexp::simpleFindJSC() +{ +#ifdef HAVE_JSC + int numr; + const char * errmsg=" "; + QString rxs("happy"); + JSRegExp *rx = jsRegExpCompile(rxs.utf16(), rxs.length(), JSRegExpDoNotIgnoreCase, JSRegExpSingleLine, 0, &errmsg); + QVERIFY(rx != 0); + QString s(str1); + int offsetVector[3]; + QBENCHMARK{ + numr = jsRegExpExecute(rx, s.utf16(), s.length(), 0, offsetVector, 3); + } + jsRegExpFree(rx); + QCOMPARE(numr, 1); + QCOMPARE(offsetVector[0], 11); +#else + QSKIP("JSC is not enabled for this platform"); +#endif +} + +void tst_qregexp::rangeReplaceJSC() +{ +#ifdef HAVE_JSC + QScriptValue r; + QScriptEngine engine; + engine.globalObject().setProperty("s", str1); + QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/[a-f]/g, '-') } )"); + QVERIFY(replaceFunc.isFunction()); + QBENCHMARK{ + r = replaceFunc.call(QScriptValue()); + } + QCOMPARE(r.toString(), QString("W- -r- -ll h-ppy monk-ys")); +#else + QSKIP("JSC is not enabled for this platform"); +#endif +} + +void tst_qregexp::matchReplaceJSC() +{ +#ifdef HAVE_JSC + QScriptValue r; + QScriptEngine engine; + engine.globalObject().setProperty("s", str1); + QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/[^a-f]*([a-f]+)[^a-f]*/g, '$1') } )"); + QVERIFY(replaceFunc.isFunction()); + QBENCHMARK{ + r = replaceFunc.call(QScriptValue()); + } + QCOMPARE(r.toString(), QString("eaeaae")); +#else + QSKIP("JSC is not enabled for this platform"); +#endif +} + +void tst_qregexp::horribleWrongReplaceJSC() +{ +#ifdef HAVE_JSC + QScriptValue r; + QScriptEngine engine; + engine.globalObject().setProperty("s", str2); + QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/.*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*/gm, '$1.$2.$3') } )"); + QVERIFY(replaceFunc.isFunction()); + QBENCHMARK{ + r = replaceFunc.call(QScriptValue()); + } + QCOMPARE(r.toString(), str2); +#else + QSKIP("JSC is not enabled for this platform"); +#endif +} + +void tst_qregexp::horribleReplaceJSC() +{ +#ifdef HAVE_JSC + QScriptValue r; + QScriptEngine engine; + // the m flag doesn't actually work here; dunno + engine.globalObject().setProperty("s", str2.replace('\n', ' ')); + QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/.*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*/gm, '$1.$2.$3') } )"); + QVERIFY(replaceFunc.isFunction()); + QBENCHMARK{ + r = replaceFunc.call(QScriptValue()); + } + QCOMPARE(r.toString(), QString("1.2.3")); +#else + QSKIP("JSC is not enabled for this platform"); +#endif +} + +void tst_qregexp::simpleFindBoost() +{ +#ifdef HAVE_BOOST + int roff; + boost::regex rx ("happy", boost::regex_constants::perl); + std::string s = str1.toStdString(); + std::string::const_iterator start, end; + start = s.begin(); + end = s.end(); + boost::match_flag_type flags = boost::match_default; + QBENCHMARK{ + boost::match_results what; + regex_search(start, end, what, rx, flags); + roff = (what[0].first)-start; + } + QCOMPARE(roff, 11); +#else + QSKIP("Boost is not enabled for this platform"); +#endif + +} + +void tst_qregexp::rangeReplaceBoost() +{ +#ifdef HAVE_BOOST + boost::regex pattern ("[a-f]", boost::regex_constants::perl); + std::string s = str1.toStdString(); + std::string r; + QBENCHMARK{ + r = boost::regex_replace (s, pattern, "-"); + } + QCOMPARE(r, std::string("W- -r- -ll h-ppy monk-ys")); +#else + QSKIP("Boost is not enabled for this platform"); +#endif +} + +void tst_qregexp::matchReplaceBoost() +{ +#ifdef HAVE_BOOST + boost::regex pattern ("[^a-f]*([a-f]+)[^a-f]*",boost::regex_constants::perl); + std::string s = str1.toStdString(); + std::string r; + QBENCHMARK{ + r = boost::regex_replace (s, pattern, "$1"); + } + QCOMPARE(r, std::string("eaeaae")); +#else + QSKIP("Boost is not enabled for this platform"); +#endif +} + +void tst_qregexp::horribleWrongReplaceBoost() +{ +#ifdef HAVE_BOOST + boost::regex pattern (".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*", boost::regex_constants::perl); + std::string s = str2.toStdString(); + std::string r; + QBENCHMARK{ + r = boost::regex_replace (s, pattern, "$1.$2.$3"); + } + QCOMPARE(r, s); +#else + QSKIP("Boost is not enabled for this platform"); +#endif +} + +void tst_qregexp::horribleReplaceBoost() +{ +#ifdef HAVE_BOOST + boost::regex pattern (".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*", boost::regex_constants::perl); + std::string s = str2.toStdString(); + std::string r; + QBENCHMARK{ + r = boost::regex_replace (s, pattern, "$1.$2.$3"); + } + QCOMPARE(r, std::string("1.2.3")); +#else + QSKIP("Boost is not enabled for this platform"); +#endif +} + +QTEST_MAIN(tst_qregexp) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qregexp/qregexp.pro b/tests/benchmarks/corelib/text/qregexp/qregexp.pro new file mode 100644 index 0000000000..f64ae781a2 --- /dev/null +++ b/tests/benchmarks/corelib/text/qregexp/qregexp.pro @@ -0,0 +1,20 @@ +TEMPLATE = app +TARGET = tst_bench_qregexp +QT = core testlib +CONFIG += release exceptions + +SOURCES += main.cpp +RESOURCES += qregexp.qrc + +qtHaveModule(script):!pcre { + DEFINES += HAVE_JSC + QT += script +} + +!qnx { + exists($$[QT_SYSROOT]/usr/include/boost/regex.hpp) { + DEFINES += HAVE_BOOST + LIBS += -lboost_regex + } +} + diff --git a/tests/benchmarks/corelib/text/qregexp/qregexp.qrc b/tests/benchmarks/corelib/text/qregexp/qregexp.qrc new file mode 100644 index 0000000000..a7fe13c035 --- /dev/null +++ b/tests/benchmarks/corelib/text/qregexp/qregexp.qrc @@ -0,0 +1,6 @@ + + + main.cpp + + + diff --git a/tests/benchmarks/corelib/text/qstring/main.cpp b/tests/benchmarks/corelib/text/qstring/main.cpp new file mode 100644 index 0000000000..826a843c10 --- /dev/null +++ b/tests/benchmarks/corelib/text/qstring/main.cpp @@ -0,0 +1,193 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#include +#include +#include + +class tst_QString: public QObject +{ + Q_OBJECT +public: + tst_QString(); +private slots: + void section_regexp_data() { section_data_impl(); } + void section_regexp() { section_impl(); } + void section_regularexpression_data() { section_data_impl(); } + void section_regularexpression() { section_impl(); } + void section_string_data() { section_data_impl(false); } + void section_string() { section_impl(); } + + void toUpper_data(); + void toUpper(); + void toLower_data(); + void toLower(); + void toCaseFolded_data(); + void toCaseFolded(); + +private: + void section_data_impl(bool includeRegExOnly = true); + template void section_impl(); +}; + +tst_QString::tst_QString() +{ +} + +void tst_QString::section_data_impl(bool includeRegExOnly) +{ + QTest::addColumn("s"); + QTest::addColumn("sep"); + QTest::addColumn("isRegExp"); + + QTest::newRow("IPv4") << QStringLiteral("192.168.0.1") << QStringLiteral(".") << false; + QTest::newRow("IPv6") << QStringLiteral("2001:0db8:85a3:0000:0000:8a2e:0370:7334") << QStringLiteral(":") << false; + if (includeRegExOnly) { + QTest::newRow("IPv6-reversed-roles") << QStringLiteral("2001:0db8:85a3:0000:0000:8a2e:0370:7334") << QStringLiteral("\\d+") << true; + QTest::newRow("IPv6-complex") << QStringLiteral("2001:0db8:85a3:0000:0000:8a2e:0370:7334") << QStringLiteral("(\\d+):\\1") << true; + } +} + +template +inline QString escape(const QString &s) +{ return RX::escape(s); } + +template <> +inline QString escape(const QString &s) +{ return s; } + +template +inline void optimize(RX &) {} + +template <> +inline void optimize(QRegularExpression &rx) +{ rx.optimize(); } + +template +void tst_QString::section_impl() +{ + QFETCH(QString, s); + QFETCH(QString, sep); + QFETCH(bool, isRegExp); + + RX rx(isRegExp ? sep : escape(sep)); + optimize(rx); + for (int i = 0; i < 20; ++i) + (void) s.count(rx); // make (s, rx) hot + + QBENCHMARK { + const QString result = s.section(rx, 0, 16); + Q_UNUSED(result); + } +} + +void tst_QString::toUpper_data() +{ + QTest::addColumn("s"); + + QString lowerLatin1(300, QChar('a')); + QString upperLatin1(300, QChar('A')); + + QString lowerDeseret; + { + QString pattern; + pattern += QChar(QChar::highSurrogate(0x10428)); + pattern += QChar(QChar::lowSurrogate(0x10428)); + for (int i = 0; i < 300 / pattern.size(); ++i) + lowerDeseret += pattern; + } + QString upperDeseret; + { + QString pattern; + pattern += QChar(QChar::highSurrogate(0x10400)); + pattern += QChar(QChar::lowSurrogate(0x10400)); + for (int i = 0; i < 300 / pattern.size(); ++i) + upperDeseret += pattern; + } + + QString lowerLigature(600, QChar(0xFB03)); + + QTest::newRow("600") << (lowerLatin1 + lowerLatin1); + QTest::newRow("600") << (upperLatin1 + upperLatin1); + + QTest::newRow("300+300") << (lowerLatin1 + upperLatin1); + QTest::newRow("300+300") << (upperLatin1 + lowerLatin1); + + QTest::newRow("300<10428>") << (lowerDeseret + lowerDeseret); + QTest::newRow("300<10400>") << (upperDeseret + upperDeseret); + + QTest::newRow("150<10428>+150<10400>") << (lowerDeseret + upperDeseret); + QTest::newRow("150<10400>+150<10428>") << (upperDeseret + lowerDeseret); + + QTest::newRow("300a+150<10400>") << (lowerLatin1 + upperDeseret); + QTest::newRow("300a+150<10428>") << (lowerLatin1 + lowerDeseret); + QTest::newRow("300A+150<10400>") << (upperLatin1 + upperDeseret); + QTest::newRow("300A+150<10428>") << (upperLatin1 + lowerDeseret); + + QTest::newRow("600 (ligature)") << lowerLigature; +} + +void tst_QString::toUpper() +{ + QFETCH(QString, s); + + QBENCHMARK { + s.toUpper(); + } +} + +void tst_QString::toLower_data() +{ + toUpper_data(); +} + +void tst_QString::toLower() +{ + QFETCH(QString, s); + + QBENCHMARK { + s.toLower(); + } +} + +void tst_QString::toCaseFolded_data() +{ + toUpper_data(); +} + +void tst_QString::toCaseFolded() +{ + QFETCH(QString, s); + + QBENCHMARK { + s.toCaseFolded(); + } +} + +QTEST_APPLESS_MAIN(tst_QString) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qstring/qstring.pro b/tests/benchmarks/corelib/text/qstring/qstring.pro new file mode 100644 index 0000000000..9f5e34b915 --- /dev/null +++ b/tests/benchmarks/corelib/text/qstring/qstring.pro @@ -0,0 +1,5 @@ +TARGET = tst_bench_qstring +QT -= gui +QT += core testlib +SOURCES += main.cpp + diff --git a/tests/benchmarks/corelib/text/qstringbuilder/main.cpp b/tests/benchmarks/corelib/text/qstringbuilder/main.cpp new file mode 100644 index 0000000000..0de6d33846 --- /dev/null +++ b/tests/benchmarks/corelib/text/qstringbuilder/main.cpp @@ -0,0 +1,420 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// Select one of the scenarios below +#define SCENARIO 1 + +#if SCENARIO == 1 +// this is the "no harm done" version. Only operator% is active, +// with NO_CAST * defined +#define P % +#undef QT_USE_FAST_OPERATOR_PLUS +#undef QT_USE_FAST_CONCATENATION +#define QT_NO_CAST_FROM_ASCII +#define QT_NO_CAST_TO_ASCII +#endif + + +#if SCENARIO == 2 +// this is the "full" version. Operator+ is replaced by a QStringBuilder +// based version +// with NO_CAST * defined +#define P + +#define QT_USE_FAST_OPERATOR_PLUS +#define QT_USE_FAST_CONCATENATION +#define QT_NO_CAST_FROM_ASCII +#define QT_NO_CAST_TO_ASCII +#endif + +#if SCENARIO == 3 +// this is the "no harm done" version. Only operator% is active, +// with NO_CAST * _not_ defined +#define P % +#undef QT_USE_FAST_OPERATOR_PLUS +#undef QT_USE_FAST_CONCATENATION +#undef QT_NO_CAST_FROM_ASCII +#undef QT_NO_CAST_TO_ASCII +#endif + +#if SCENARIO == 4 +// this is the "full" version. Operator+ is replaced by a QStringBuilder +// based version +// with NO_CAST * _not_ defined +#define P + +#define QT_USE_FAST_OPERATOR_PLUS +#define QT_USE_FAST_CONCATENATION +#undef QT_NO_CAST_FROM_ASCII +#undef QT_NO_CAST_TO_ASCII +#endif + + +#include +#include +#include +#include + +#include + +#include + +#define COMPARE(a, b) QCOMPARE(a, b) +//#define COMPARE(a, b) + +#define SEP(s) qDebug() << "\n\n-------- " s " ---------"; + +#define LITERAL "some string literal" + +class tst_qstringbuilder : public QObject +{ + Q_OBJECT + +public: + tst_qstringbuilder() + : l1literal(LITERAL), + l1string(LITERAL), + ba(LITERAL), + string(l1string), + stdstring(LITERAL), + stringref(&string, 2, 10), + achar('c'), + r2(QLatin1String(LITERAL LITERAL)), + r3(QLatin1String(LITERAL LITERAL LITERAL)), + r4(QLatin1String(LITERAL LITERAL LITERAL LITERAL)), + r5(QLatin1String(LITERAL LITERAL LITERAL LITERAL LITERAL)) + {} + + +public: + enum { N = 10000 }; + + int run_traditional() + { + int s = 0; + for (int i = 0; i < N; ++i) { +#if 0 + s += QString(l1string + l1string).size(); + s += QString(l1string + l1string + l1string).size(); + s += QString(l1string + l1string + l1string + l1string).size(); + s += QString(l1string + l1string + l1string + l1string + l1string).size(); +#endif + s += QString(achar + l1string + achar).size(); + } + return s; + } + + int run_builder() + { + int s = 0; + for (int i = 0; i < N; ++i) { +#if 0 + s += QString(l1literal P l1literal).size(); + s += QString(l1literal P l1literal P l1literal).size(); + s += QString(l1literal P l1literal P l1literal P l1literal).size(); + s += QString(l1literal P l1literal P l1literal P l1literal P l1literal).size(); +#endif + s += QString(achar % l1literal % achar).size(); + } + return s; + } + +private slots: + + void separator_0() { + qDebug() << "\nIn each block the QStringBuilder based result appear first " + "(with a 'b_' prefix), QStringBased second ('q_' prefix), std::string " + "last ('s_' prefix)\n"; + } + + void separator_1() { SEP("literal + literal (builder first)"); } + + void b_2_l1literal() { + QBENCHMARK { r = l1literal P l1literal; } + COMPARE(r, r2); + } + #ifndef QT_NO_CAST_FROM_ASCII + void b_l1literal_LITERAL() { + QBENCHMARK { r = l1literal P LITERAL; } + COMPARE(r, r2); + } + #endif + void q_2_l1string() { + QBENCHMARK { r = l1string + l1string; } + COMPARE(r, r2); + } + + + void separator_2() { SEP("2 strings"); } + + void b_2_string() { + QBENCHMARK { r = string P string; } + COMPARE(r, r2); + } + void q_2_string() { + QBENCHMARK { r = string + string; } + COMPARE(r, r2); + } + void s_2_string() { + QBENCHMARK { stdr = stdstring + stdstring; } + COMPARE(stdr, stdstring + stdstring); + } + + + void separator_2c() { SEP("2 string refs"); } + + void b_2_stringref() { + QBENCHMARK { r = stringref % stringref; } + COMPARE(r, QString(stringref.toString() + stringref.toString())); + } + void q_2_stringref() { + QBENCHMARK { r = stringref.toString() + stringref.toString(); } + COMPARE(r, QString(stringref % stringref)); + } + + + void separator_2b() { SEP("3 strings"); } + + void b_3_string() { + QBENCHMARK { r = string P string P string; } + COMPARE(r, r3); + } + void q_3_string() { + QBENCHMARK { r = string + string + string; } + COMPARE(r, r3); + } + void s_3_string() { + QBENCHMARK { stdr = stdstring + stdstring + stdstring; } + COMPARE(stdr, stdstring + stdstring + stdstring); + } + + void separator_2e() { SEP("4 strings"); } + + void b_4_string() { + QBENCHMARK { r = string P string P string P string; } + COMPARE(r, r4); + } + void q_4_string() { + QBENCHMARK { r = string + string + string + string; } + COMPARE(r, r4); + } + void s_4_string() { + QBENCHMARK { stdr = stdstring + stdstring + stdstring + stdstring; } + COMPARE(stdr, stdstring + stdstring + stdstring + stdstring); + } + + + + void separator_2a() { SEP("string + literal (builder first)"); } + + void b_string_l1literal() { + QBENCHMARK { r = string % l1literal; } + COMPARE(r, r2); + } + #ifndef QT_NO_CAST_FROM_ASCII + void b_string_LITERAL() { + QBENCHMARK { r = string P LITERAL; } + COMPARE(r, r2); + } + void b_LITERAL_string() { + QBENCHMARK { r = LITERAL P string; } + COMPARE(r, r2); + } + #endif + void b_string_l1string() { + QBENCHMARK { r = string P l1string; } + COMPARE(r, r2); + } + void q_string_l1literal() { + QBENCHMARK { r = string + l1string; } + COMPARE(r, r2); + } + void q_string_l1string() { + QBENCHMARK { r = string + l1string; } + COMPARE(r, r2); + } + void s_LITERAL_string() { + QBENCHMARK { stdr = LITERAL + stdstring; } + COMPARE(stdr, stdstring + stdstring); + } + + + void separator_3() { SEP("3 literals"); } + + void b_3_l1literal() { + QBENCHMARK { r = l1literal P l1literal P l1literal; } + COMPARE(r, r3); + } + void q_3_l1string() { + QBENCHMARK { r = l1string + l1string + l1string; } + COMPARE(r, r3); + } + void s_3_l1string() { + QBENCHMARK { stdr = stdstring + LITERAL + LITERAL; } + COMPARE(stdr, stdstring + stdstring + stdstring); + } + + + void separator_4() { SEP("4 literals"); } + + void b_4_l1literal() { + QBENCHMARK { r = l1literal P l1literal P l1literal P l1literal; } + COMPARE(r, r4); + } + void q_4_l1string() { + QBENCHMARK { r = l1string + l1string + l1string + l1string; } + COMPARE(r, r4); + } + + + void separator_5() { SEP("5 literals"); } + + void b_5_l1literal() { + QBENCHMARK { r = l1literal P l1literal P l1literal P l1literal P l1literal; } + COMPARE(r, r5); + } + + void q_5_l1string() { + QBENCHMARK { r = l1string + l1string + l1string + l1string + l1string; } + COMPARE(r, r5); + } + + + void separator_6() { SEP("4 chars"); } + + void b_string_4_char() { + QBENCHMARK { r = string + achar + achar + achar + achar; } + COMPARE(r, QString(string P achar P achar P achar P achar)); + } + + void q_string_4_char() { + QBENCHMARK { r = string + achar + achar + achar + achar; } + COMPARE(r, QString(string P achar P achar P achar P achar)); + } + + void s_string_4_char() { + QBENCHMARK { stdr = stdstring + 'c' + 'c' + 'c' + 'c'; } + COMPARE(stdr, stdstring + 'c' + 'c' + 'c' + 'c'); + } + + + void separator_7() { SEP("char + string + char"); } + + void b_char_string_char() { + QBENCHMARK { r = achar + string + achar; } + COMPARE(r, QString(achar P string P achar)); + } + + void q_char_string_char() { + QBENCHMARK { r = achar + string + achar; } + COMPARE(r, QString(achar P string P achar)); + } + + void s_char_string_char() { + QBENCHMARK { stdr = 'c' + stdstring + 'c'; } + COMPARE(stdr, 'c' + stdstring + 'c'); + } + + + void separator_8() { SEP("string.arg"); } + + void b_string_arg() { + const QString pattern = l1string + QString::fromLatin1("%1") + l1string; + QBENCHMARK { r = l1literal P string P l1literal; } + COMPARE(r, r3); + } + + void q_string_arg() { + const QString pattern = l1string + QLatin1String("%1") + l1string; + QBENCHMARK { r = pattern.arg(string); } + COMPARE(r, r3); + } + + void q_bytearray_arg() { + QByteArray result; + QBENCHMARK { result = ba + ba + ba; } + } + + + void separator_9() { SEP("QString::reserve()"); } + + void b_reserve() { + QBENCHMARK { + r.clear(); + r = string P string P string P string; + } + COMPARE(r, r4); + } + void b_reserve_lit() { + QBENCHMARK { + r.clear(); + r = string P l1literal P string P string; + } + COMPARE(r, r4); + } + void s_reserve() { + QBENCHMARK { + r.clear(); + r.reserve(string.size() + string.size() + string.size() + string.size()); + r += string; + r += string; + r += string; + r += string; + } + COMPARE(r, r4); + } + void s_reserve_lit() { + QBENCHMARK { + r.clear(); + //r.reserve(string.size() + qstrlen(l1string.latin1()) + // + string.size() + string.size()); + r.reserve(1024); + r += string; + r += l1string; + r += string; + r += string; + } + COMPARE(r, r4); + } + +private: + const QLatin1String l1literal; + const QLatin1String l1string; + const QByteArray ba; + const QString string; + const std::string stdstring; + const QStringRef stringref; + const QLatin1Char achar; + const QString r2, r3, r4, r5; + + // short cuts for results + QString r; + std::string stdr; +}; + +QTEST_MAIN(tst_qstringbuilder) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qstringbuilder/qstringbuilder.pro b/tests/benchmarks/corelib/text/qstringbuilder/qstringbuilder.pro new file mode 100644 index 0000000000..fa4cbe3c13 --- /dev/null +++ b/tests/benchmarks/corelib/text/qstringbuilder/qstringbuilder.pro @@ -0,0 +1,11 @@ +TEMPLATE = app +TARGET = tst_bench_qstringbuilder + +QMAKE_CXXFLAGS += -g +QMAKE_CFLAGS += -g + +QT = core testlib + +CONFIG += release + +SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/text/qstringlist/.gitignore b/tests/benchmarks/corelib/text/qstringlist/.gitignore new file mode 100644 index 0000000000..3e0cdc952f --- /dev/null +++ b/tests/benchmarks/corelib/text/qstringlist/.gitignore @@ -0,0 +1 @@ +tst_qstringlist diff --git a/tests/benchmarks/corelib/text/qstringlist/main.cpp b/tests/benchmarks/corelib/text/qstringlist/main.cpp new file mode 100644 index 0000000000..ae355a8b89 --- /dev/null +++ b/tests/benchmarks/corelib/text/qstringlist/main.cpp @@ -0,0 +1,201 @@ +/**************************************************************************** +** +** Copyright (C) 2016 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include + +#include +#include +#include + +class tst_QStringList: public QObject +{ + Q_OBJECT + +private slots: + void join() const; + void join_data() const; + + void split_qlist_qbytearray() const; + void split_qlist_qbytearray_data() const { return split_data(); } + + void split_data() const; + void split_qlist_qstring() const; + void split_qlist_qstring_data() const { return split_data(); } + + void split_stdvector_stdstring() const; + void split_stdvector_stdstring_data() const { return split_data(); } + + void split_stdvector_stdwstring() const; + void split_stdvector_stdwstring_data() const { return split_data(); } + + void split_stdlist_stdstring() const; + void split_stdlist_stdstring_data() const { return split_data(); } + +private: + static QStringList populateList(const int count, const QString &unit); + static QString populateString(const int count, const QString &unit); +}; + +QStringList tst_QStringList::populateList(const int count, const QString &unit) +{ + QStringList retval; + + for (int i = 0; i < count; ++i) + retval.append(unit); + + return retval; +} + +QString tst_QStringList::populateString(const int count, const QString &unit) +{ + QString retval; + + for (int i = 0; i < count; ++i) { + retval.append(unit); + retval.append(QLatin1Char(':')); + } + + return retval; +} + +void tst_QStringList::join() const +{ + QFETCH(QStringList, input); + QFETCH(QString, separator); + + QBENCHMARK { + input.join(separator); + } +} + +void tst_QStringList::join_data() const +{ + QTest::addColumn("input"); + QTest::addColumn("separator"); + + QTest::newRow("") + << populateList(100, QLatin1String("unit")) + << QString(); + + QTest::newRow("") + << populateList(1000, QLatin1String("unit")) + << QString(); + + QTest::newRow("") + << populateList(10000, QLatin1String("unit")) + << QString(); + + QTest::newRow("") + << populateList(100000, QLatin1String("unit")) + << QString(); +} + +void tst_QStringList::split_data() const +{ + QTest::addColumn("input"); + QString unit = QLatin1String("unit") + QString(100, QLatin1Char('s')); + //QTest::newRow("") << populateString(10, unit); + QTest::newRow("") << populateString(100, unit); + //QTest::newRow("") << populateString(100, unit); + //QTest::newRow("") << populateString(1000, unit); + //QTest::newRow("") << populateString(10000, unit); +} + +void tst_QStringList::split_qlist_qbytearray() const +{ + QFETCH(QString, input); + const char splitChar = ':'; + QByteArray ba = input.toLatin1(); + + QBENCHMARK { + ba.split(splitChar); + } +} + +void tst_QStringList::split_qlist_qstring() const +{ + QFETCH(QString, input); + const QChar splitChar = ':'; + + QBENCHMARK { + input.split(splitChar); + } +} + +void tst_QStringList::split_stdvector_stdstring() const +{ + QFETCH(QString, input); + const char split_char = ':'; + std::string stdinput = input.toStdString(); + + QBENCHMARK { + std::istringstream split(stdinput); + std::vector token; + for (std::string each; + std::getline(split, each, split_char); + token.push_back(each)) + ; + } +} + +void tst_QStringList::split_stdvector_stdwstring() const +{ + QFETCH(QString, input); + const wchar_t split_char = ':'; + std::wstring stdinput = input.toStdWString(); + + QBENCHMARK { + std::wistringstream split(stdinput); + std::vector token; + for (std::wstring each; + std::getline(split, each, split_char); + token.push_back(each)) + ; + } +} + +void tst_QStringList::split_stdlist_stdstring() const +{ + QFETCH(QString, input); + const char split_char = ':'; + std::string stdinput = input.toStdString(); + + QBENCHMARK { + std::istringstream split(stdinput); + std::list token; + for (std::string each; + std::getline(split, each, split_char); + token.push_back(each)) + ; + } +} + +QTEST_MAIN(tst_QStringList) + +#include "main.moc" diff --git a/tests/benchmarks/corelib/text/qstringlist/qstringlist.pro b/tests/benchmarks/corelib/text/qstringlist/qstringlist.pro new file mode 100644 index 0000000000..5803e7da0e --- /dev/null +++ b/tests/benchmarks/corelib/text/qstringlist/qstringlist.pro @@ -0,0 +1,5 @@ +TARGET = tst_bench_qstringlist +CONFIG -= debug +CONFIG += release +QT = core testlib +SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/text/text.pro b/tests/benchmarks/corelib/text/text.pro new file mode 100644 index 0000000000..8c15d0b0c5 --- /dev/null +++ b/tests/benchmarks/corelib/text/text.pro @@ -0,0 +1,10 @@ +TEMPLATE = subdirs +SUBDIRS = \ + qbytearray \ + qchar \ + qlocale \ + qregexp \ + qstringbuilder \ + qstringlist + +*g++*: SUBDIRS += qstring diff --git a/tests/benchmarks/corelib/tools/qbytearray/main.cpp b/tests/benchmarks/corelib/tools/qbytearray/main.cpp deleted file mode 100644 index e421e7436b..0000000000 --- a/tests/benchmarks/corelib/tools/qbytearray/main.cpp +++ /dev/null @@ -1,264 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Copyright (C) 2016 Intel Corporation. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ -#include -#include -#include -#include - -#include - - -class tst_qbytearray : public QObject -{ - Q_OBJECT - QByteArray sourcecode; -private slots: - void initTestCase(); - void append(); - void append_data(); - - void latin1Uppercasing_qt54(); - void latin1Uppercasing_xlate(); - void latin1Uppercasing_xlate_checked(); - void latin1Uppercasing_category(); - void latin1Uppercasing_bitcheck(); -}; - -void tst_qbytearray::initTestCase() -{ - QFile self(QFINDTESTDATA("main.cpp")); - QVERIFY(self.open(QIODevice::ReadOnly)); - sourcecode = self.readAll(); -} - -void tst_qbytearray::append_data() -{ - QTest::addColumn("size"); - QTest::newRow("1") << int(1); - QTest::newRow("10") << int(10); - QTest::newRow("100") << int(100); - QTest::newRow("1000") << int(1000); - QTest::newRow("10000") << int(10000); - QTest::newRow("100000") << int(100000); - QTest::newRow("1000000") << int(1000000); - QTest::newRow("10000000") << int(10000000); - QTest::newRow("100000000") << int(100000000); -} - -void tst_qbytearray::append() -{ - QFETCH(int, size); - - QByteArray ba; - QBENCHMARK { - QByteArray ba2(size, 'x'); - ba.append(ba2); - ba.clear(); - } -} - -void tst_qbytearray::latin1Uppercasing_qt54() -{ - QByteArray s = sourcecode; - s.detach(); - - // the following was copied from qbytearray.cpp (except for the QBENCHMARK macro): - uchar *p_orig = reinterpret_cast(s.data()); - uchar *e = reinterpret_cast(s.end()); - - QBENCHMARK { - uchar *p = p_orig; - if (p) { - while (p != e) { - *p = QChar::toLower((ushort)*p); - p++; - } - } - } -} - - -/* -#!/usr/bin/perl -l -use feature "unicode_strings" -for (0..255) { - $up = uc(chr($_)); - $up = chr($_) if ord($up) > 0x100 || length $up > 1; - printf "0x%02x,", ord($up); - print "" if ($_ & 0xf) == 0xf; -} -*/ -static const uchar uppercased[256] = { - 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, - 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f, - 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f, - 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f, - 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f, - 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f, - 0x60,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f, - 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x7b,0x7c,0x7d,0x7e,0x7f, - 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f, - 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f, - 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf, - 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf, - 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf, - 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf, - 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf, - 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xf7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xff -}; -void tst_qbytearray::latin1Uppercasing_xlate() -{ - QByteArray output = sourcecode; - output.detach(); - char *dst_orig = output.data(); - const char *src_orig = sourcecode.constBegin(); - const char *end = sourcecode.constEnd(); - QBENCHMARK { - char *dst = dst_orig; - for (const char *src = src_orig; src != end; ++src, ++dst) - *dst = uppercased[uchar(*src)]; - } -} - -void tst_qbytearray::latin1Uppercasing_xlate_checked() -{ - QByteArray output = sourcecode; - output.detach(); - char *dst_orig = output.data(); - const char *src_orig = sourcecode.constBegin(); - const char *end = sourcecode.constEnd(); - QBENCHMARK { - char *dst = dst_orig; - for (const char *src = src_orig; src != end; ++src, ++dst) { - uchar ch = uchar(*src); - uchar converted = uppercased[ch]; - if (ch != converted) - *dst = converted; - } - } -} - -/* -#!/bin/perl -l -use feature "unicode_strings"; -sub categorize($) { - # 'ß' and 'ÿ' are lowercase, but we cannot uppercase them - return 0 if $_[0] == 0xDF || $_[0] == 0xFF; - $ch = chr($_[0]); - return 2 if uc($ch) ne $ch; - return 1 if lc($ch) ne $ch; - return 0; -} -for (0..255) { - printf "%d,", categorize($_); - print "" if ($_ & 0xf) == 0xf; -} -*/ -static const char categories[256] = { - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,0 -}; - -void tst_qbytearray::latin1Uppercasing_category() -{ - QByteArray output = sourcecode; - output.detach(); - char *dst_orig = output.data(); - const char *src_orig = sourcecode.constBegin(); - const char *end = sourcecode.constEnd(); - QBENCHMARK { - char *dst = dst_orig; - for (const char *src = src_orig; src != end; ++src, ++dst) - *dst = categories[uchar(*src)] == 1 ? *src & ~0x20 : *src; - } -} - -/* -#!/bin/perl -l -use feature "unicode_strings"; -sub categorize($) { - # 'ß' and 'ÿ' are lowercase, but we cannot uppercase them - return 0 if $_[0] == 0xDF || $_[0] == 0xFF; - $ch = chr($_[0]); - return 2 if uc($ch) ne $ch; - return 1 if lc($ch) ne $ch; - return 0; -} -for $row (0..7) { - $val = 0; - for $col (0..31) { - $val |= (1<<$col) - if categorize($row * 31 + $col) == 2; - } - printf "0x%08x,", $val; -} -*/ - -static const quint32 shouldUppercase[8] = { - 0x00000000,0x00000000,0x00000000,0x3ffffff0,0x00000000,0x04000000,0x00000000,0xbfffff80 -}; - -static bool bittest(const quint32 *data, uchar bit) -{ - static const unsigned bitsperelem = sizeof(*data) * CHAR_BIT; - return data[bit / bitsperelem] & (1 << (bit & (bitsperelem - 1))); -} - -void tst_qbytearray::latin1Uppercasing_bitcheck() -{ - QByteArray output = sourcecode; - output.detach(); - char *dst_orig = output.data(); - const char *src_orig = sourcecode.constBegin(); - const char *end = sourcecode.constEnd(); - QBENCHMARK { - char *dst = dst_orig; - for (const char *src = src_orig; src != end; ++src, ++dst) - *dst = bittest(shouldUppercase, *src) ? uchar(*src) & ~0x20 : uchar(*src); - } -} - - -QTEST_MAIN(tst_qbytearray) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qbytearray/qbytearray.pro b/tests/benchmarks/corelib/tools/qbytearray/qbytearray.pro deleted file mode 100644 index cf28b0247f..0000000000 --- a/tests/benchmarks/corelib/tools/qbytearray/qbytearray.pro +++ /dev/null @@ -1,7 +0,0 @@ -TEMPLATE = app -TARGET = tst_bench_qbytearray - -QT = core testlib - -TESTDATA += main.cpp -SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/tools/qchar/main.cpp b/tests/benchmarks/corelib/tools/qchar/main.cpp deleted file mode 100644 index 4dcf86786d..0000000000 --- a/tests/benchmarks/corelib/tools/qchar/main.cpp +++ /dev/null @@ -1,136 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ -#include -#include - -class tst_QChar: public QObject -{ - Q_OBJECT -private slots: - void isUpper_data(); - void isUpper(); - void isLower_data(); - void isLower(); - void isLetter_data(); - void isLetter(); - void isDigit_data(); - void isDigit(); - void isLetterOrNumber_data(); - void isLetterOrNumber(); - void isSpace_data(); - void isSpace(); -}; - -void tst_QChar::isUpper_data() -{ - QTest::addColumn("c"); - - QTest::newRow("k") << QChar('k'); - QTest::newRow("K") << QChar('K'); - QTest::newRow("5") << QChar('5'); - QTest::newRow("\\0") << QChar(); - QTest::newRow("space") << QChar(' '); - QTest::newRow("\\u3C20") << QChar(0x3C20); -} - -void tst_QChar::isUpper() -{ - QFETCH(QChar, c); - QBENCHMARK { - c.isUpper(); - } -} - -void tst_QChar::isLower_data() -{ - isUpper_data(); -} - -void tst_QChar::isLower() -{ - QFETCH(QChar, c); - QBENCHMARK { - c.isLower(); - } -} - -void tst_QChar::isLetter_data() -{ - isUpper_data(); -} - -void tst_QChar::isLetter() -{ - QFETCH(QChar, c); - QBENCHMARK { - c.isLetter(); - } -} - -void tst_QChar::isDigit_data() -{ - isUpper_data(); -} - -void tst_QChar::isDigit() -{ - QFETCH(QChar, c); - QBENCHMARK { - c.isDigit(); - } -} - -void tst_QChar::isLetterOrNumber_data() -{ - isUpper_data(); -} - -void tst_QChar::isLetterOrNumber() -{ - QFETCH(QChar, c); - QBENCHMARK { - c.isLetterOrNumber(); - } -} - -void tst_QChar::isSpace_data() -{ - isUpper_data(); -} - -void tst_QChar::isSpace() -{ - QFETCH(QChar, c); - QBENCHMARK { - c.isSpace(); - } -} - -QTEST_MAIN(tst_QChar) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qchar/qchar.pro b/tests/benchmarks/corelib/tools/qchar/qchar.pro deleted file mode 100644 index 80a9861f48..0000000000 --- a/tests/benchmarks/corelib/tools/qchar/qchar.pro +++ /dev/null @@ -1,3 +0,0 @@ -TARGET = tst_bench_qchar -QT = core testlib -SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/tools/qhash/paths_small_data.txt b/tests/benchmarks/corelib/tools/qhash/paths_small_data.txt index d5acd28820..662285296f 100644 --- a/tests/benchmarks/corelib/tools/qhash/paths_small_data.txt +++ b/tests/benchmarks/corelib/tools/qhash/paths_small_data.txt @@ -47,13 +47,38 @@ ./codecs/.obj/debug-shared ./.pch ./.pch/debug-shared +./text +./text/text.pro +./text/qregexp +./text/qregexp/qregexp.qrc +./text/qregexp/main.cpp +./text/qregexp/Makefile +./text/qregexp/qregexp.pro +./text/qstringbuilder +./text/qstringbuilder/main.cpp +./text/qstringbuilder/Makefile +./text/qstringbuilder/qstringbuilder.pro +./text/qstring +./text/qstring/generatelist.pl +./text/qstring/data.h +./text/qstring/qstring.pro +./text/qstring/main.cpp +./text/qstring/data.cpp +./text/qstring/Makefile +./text/qstring/utf-8.txt +./text/qstringlist +./text/qstringlist/qstringlist.pro +./text/qstringlist/main.cpp +./text/qstringlist/.gitignore +./text/qstringlist/Makefile +./text/qbytearray +./text/qbytearray/qbytearray.pro +./text/qbytearray/main.cpp +./text/qbytearray/Makefile +./text/.pch +./text/.pch/debug-shared ./tools ./tools/tools.pro -./tools/qregexp -./tools/qregexp/qregexp.qrc -./tools/qregexp/main.cpp -./tools/qregexp/Makefile -./tools/qregexp/qregexp.pro ./tools/qvector ./tools/qvector/tst_vector ./tools/qvector/.pch @@ -72,31 +97,10 @@ ./tools/qvector/qvector.pro ./tools/.pch ./tools/.pch/debug-shared -./tools/qstringbuilder -./tools/qstringbuilder/main.cpp -./tools/qstringbuilder/Makefile -./tools/qstringbuilder/qstringbuilder.pro ./tools/containers-sequential ./tools/containers-sequential/containers-sequential.pro ./tools/containers-sequential/main.cpp ./tools/containers-sequential/Makefile -./tools/qstring -./tools/qstring/generatelist.pl -./tools/qstring/data.h -./tools/qstring/qstring.pro -./tools/qstring/main.cpp -./tools/qstring/data.cpp -./tools/qstring/Makefile -./tools/qstring/utf-8.txt -./tools/qstringlist -./tools/qstringlist/qstringlist.pro -./tools/qstringlist/main.cpp -./tools/qstringlist/.gitignore -./tools/qstringlist/Makefile -./tools/qbytearray -./tools/qbytearray/qbytearray.pro -./tools/qbytearray/main.cpp -./tools/qbytearray/Makefile ./tools/containers-associative ./tools/containers-associative/containers-associative.pro ./tools/containers-associative/main.cpp diff --git a/tests/benchmarks/corelib/tools/qlocale/main.cpp b/tests/benchmarks/corelib/tools/qlocale/main.cpp deleted file mode 100644 index 38d94af143..0000000000 --- a/tests/benchmarks/corelib/tools/qlocale/main.cpp +++ /dev/null @@ -1,70 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtCore module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include -#include - -class tst_QLocale : public QObject -{ - Q_OBJECT - -private Q_SLOTS: - void toUpper_QLocale_1(); - void toUpper_QLocale_2(); - void toUpper_QString(); -}; - -static QString data() -{ - return QStringLiteral("/qt-5/qtbase/tests/benchmarks/corelib/tools/qlocale"); -} - -#define LOOP(s) for (int i = 0; i < 5000; ++i) { s; } - -void tst_QLocale::toUpper_QLocale_1() -{ - QString s = data(); - QBENCHMARK { LOOP(QLocale().toUpper(s)) } -} - -void tst_QLocale::toUpper_QLocale_2() -{ - QString s = data(); - QLocale l; - QBENCHMARK { LOOP(l.toUpper(s)) } -} - -void tst_QLocale::toUpper_QString() -{ - QString s = data(); - QBENCHMARK { LOOP(s.toUpper()) } -} - -QTEST_MAIN(tst_QLocale) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qlocale/qlocale.pro b/tests/benchmarks/corelib/tools/qlocale/qlocale.pro deleted file mode 100644 index e56bbe0341..0000000000 --- a/tests/benchmarks/corelib/tools/qlocale/qlocale.pro +++ /dev/null @@ -1,4 +0,0 @@ -TARGET = tst_bench_qlocale -QT = core testlib - -SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/tools/qregexp/main.cpp b/tests/benchmarks/corelib/tools/qregexp/main.cpp deleted file mode 100644 index 798b23f2b0..0000000000 --- a/tests/benchmarks/corelib/tools/qregexp/main.cpp +++ /dev/null @@ -1,615 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include -#include -#include -#include - -#include -#ifdef HAVE_BOOST -#include -#endif - -#ifdef HAVE_JSC -#include -#include "pcre/pcre.h" -#endif -#define ZLIB_VERSION "1.2.3.4" - -class tst_qregexp : public QObject -{ - Q_OBJECT -public: - tst_qregexp(); -private slots: - void escape_old(); - void escape_old_data() { escape_data(); } - void escape_new1(); - void escape_new1_data() { escape_data(); } - void escape_new2(); - void escape_new2_data() { escape_data(); } - void escape_new3(); - void escape_new3_data() { escape_data(); } - void escape_new4(); - void escape_new4_data() { escape_data(); } -/* - JSC outperforms everything. - Boost is less impressive then expected. - */ - void simpleFind1(); - void rangeReplace1(); - void matchReplace1(); - - void simpleFind2(); - void rangeReplace2(); - void matchReplace2(); - - void simpleFindJSC(); - void rangeReplaceJSC(); - void matchReplaceJSC(); - - void simpleFindBoost(); - void rangeReplaceBoost(); - void matchReplaceBoost(); - -/* those apply an (incorrect) regexp on entire source - (this main.cpp). JSC appears to handle this - (ab)use case best. QRegExp performs extremly bad. - */ - void horribleWrongReplace1(); - void horribleReplace1(); - void horribleReplace2(); - void horribleWrongReplace2(); - void horribleWrongReplaceJSC(); - void horribleReplaceJSC(); - void horribleWrongReplaceBoost(); - void horribleReplaceBoost(); -private: - QString str1; - QString str2; - void escape_data(); -}; - -tst_qregexp::tst_qregexp() - :QObject() - ,str1("We are all happy monkeys") -{ - QFile f(":/main.cpp"); - f.open(QFile::ReadOnly); - str2=f.readAll(); -} - -static void verify(const QString "ed, const QString &expected) -{ - if (quoted != expected) - qDebug() << "ERROR:" << quoted << expected; -} - -void tst_qregexp::escape_data() -{ - QTest::addColumn("pattern"); - QTest::addColumn("expected"); - - QTest::newRow("escape 0") << "Hello world" << "Hello world"; - QTest::newRow("escape 1") << "(Hello world)" << "\\(Hello world\\)"; - { - QString s; - for (int i = 0; i < 10; ++i) - s += "(escape)"; - QTest::newRow("escape 10") << s << QRegExp::escape(s); - } - { - QString s; - for (int i = 0; i < 100; ++i) - s += "(escape)"; - QTest::newRow("escape 100") << s << QRegExp::escape(s); - } -} - -void tst_qregexp::escape_old() -{ - QFETCH(QString, pattern); - QFETCH(QString, expected); - - QBENCHMARK { - static const char meta[] = "$()*+.?[\\]^{|}"; - QString quoted = pattern; - int i = 0; - - while (i < quoted.length()) { - if (strchr(meta, quoted.at(i).toLatin1()) != 0) - quoted.insert(i++, QLatin1Char('\\')); - ++i; - } - - verify(quoted, expected); - } -} - -void tst_qregexp::escape_new1() -{ - QFETCH(QString, pattern); - QFETCH(QString, expected); - - QBENCHMARK { - QString quoted; - const int count = pattern.count(); - quoted.reserve(count * 2); - const QLatin1Char backslash('\\'); - for (int i = 0; i < count; i++) { - switch (pattern.at(i).toLatin1()) { - case '$': - case '(': - case ')': - case '*': - case '+': - case '.': - case '?': - case '[': - case '\\': - case ']': - case '^': - case '{': - case '|': - case '}': - quoted.append(backslash); - } - quoted.append(pattern.at(i)); - } - verify(quoted, expected); - } -} - -void tst_qregexp::escape_new2() -{ - QFETCH(QString, pattern); - QFETCH(QString, expected); - - QBENCHMARK { - int count = pattern.count(); - const QLatin1Char backslash('\\'); - QString quoted(count * 2, backslash); - const QChar *patternData = pattern.data(); - QChar *quotedData = quoted.data(); - int escaped = 0; - for ( ; --count >= 0; ++patternData) { - const QChar c = *patternData; - switch (c.unicode()) { - case '$': - case '(': - case ')': - case '*': - case '+': - case '.': - case '?': - case '[': - case '\\': - case ']': - case '^': - case '{': - case '|': - case '}': - ++escaped; - ++quotedData; - } - *quotedData = c; - ++quotedData; - } - quoted.resize(pattern.size() + escaped); - - verify(quoted, expected); - } -} - -void tst_qregexp::escape_new3() -{ - QFETCH(QString, pattern); - QFETCH(QString, expected); - - QBENCHMARK { - QString quoted; - const int count = pattern.count(); - quoted.reserve(count * 2); - const QLatin1Char backslash('\\'); - for (int i = 0; i < count; i++) { - switch (pattern.at(i).toLatin1()) { - case '$': - case '(': - case ')': - case '*': - case '+': - case '.': - case '?': - case '[': - case '\\': - case ']': - case '^': - case '{': - case '|': - case '}': - quoted += backslash; - } - quoted += pattern.at(i); - } - - verify(quoted, expected); - } -} - - -static inline bool needsEscaping(int c) -{ - switch (c) { - case '$': - case '(': - case ')': - case '*': - case '+': - case '.': - case '?': - case '[': - case '\\': - case ']': - case '^': - case '{': - case '|': - case '}': - return true; - } - return false; -} - -void tst_qregexp::escape_new4() -{ - QFETCH(QString, pattern); - QFETCH(QString, expected); - - QBENCHMARK { - const int n = pattern.size(); - const QChar *patternData = pattern.data(); - // try to prevent copy if no escape is needed - int i = 0; - for (int i = 0; i != n; ++i) { - const QChar c = patternData[i]; - if (needsEscaping(c.unicode())) - break; - } - if (i == n) { - verify(pattern, expected); - // no escaping needed, "return pattern" should be done here. - return; - } - const QLatin1Char backslash('\\'); - QString quoted(n * 2, backslash); - QChar *quotedData = quoted.data(); - for (int j = 0; j != i; ++j) - *quotedData++ = *patternData++; - int escaped = 0; - for (; i != n; ++i) { - const QChar c = *patternData; - if (needsEscaping(c.unicode())) { - ++escaped; - ++quotedData; - } - *quotedData = c; - ++quotedData; - ++patternData; - } - quoted.resize(n + escaped); - verify(quoted, expected); - // "return quoted" - } -} - - -void tst_qregexp::simpleFind1() -{ - int roff; - QRegExp rx("happy"); - rx.setPatternSyntax(QRegExp::RegExp); - QBENCHMARK{ - roff = rx.indexIn(str1); - } - QCOMPARE(roff, 11); -} - -void tst_qregexp::rangeReplace1() -{ - QString r; - QRegExp rx("[a-f]"); - rx.setPatternSyntax(QRegExp::RegExp); - QBENCHMARK{ - r = QString(str1).replace(rx, "-"); - } - QCOMPARE(r, QString("W- -r- -ll h-ppy monk-ys")); -} - -void tst_qregexp::matchReplace1() -{ - QString r; - QRegExp rx("[^a-f]*([a-f]+)[^a-f]*"); - rx.setPatternSyntax(QRegExp::RegExp); - QBENCHMARK{ - r = QString(str1).replace(rx, "\\1"); - } - QCOMPARE(r, QString("eaeaae")); -} - -void tst_qregexp::horribleWrongReplace1() -{ - QString r; - QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*"); - rx.setPatternSyntax(QRegExp::RegExp); - QBENCHMARK{ - r = QString(str2).replace(rx, "\\1.\\2.\\3"); - } - QCOMPARE(r, str2); -} - -void tst_qregexp::horribleReplace1() -{ - QString r; - QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*"); - rx.setPatternSyntax(QRegExp::RegExp); - QBENCHMARK{ - r = QString(str2).replace(rx, "\\1.\\2.\\3"); - } - QCOMPARE(r, QString("1.2.3")); -} - - -void tst_qregexp::simpleFind2() -{ - int roff; - QRegExp rx("happy"); - rx.setPatternSyntax(QRegExp::RegExp2); - QBENCHMARK{ - roff = rx.indexIn(str1); - } - QCOMPARE(roff, 11); -} - -void tst_qregexp::rangeReplace2() -{ - QString r; - QRegExp rx("[a-f]"); - rx.setPatternSyntax(QRegExp::RegExp2); - QBENCHMARK{ - r = QString(str1).replace(rx, "-"); - } - QCOMPARE(r, QString("W- -r- -ll h-ppy monk-ys")); -} - -void tst_qregexp::matchReplace2() -{ - QString r; - QRegExp rx("[^a-f]*([a-f]+)[^a-f]*"); - rx.setPatternSyntax(QRegExp::RegExp2); - QBENCHMARK{ - r = QString(str1).replace(rx, "\\1"); - } - QCOMPARE(r, QString("eaeaae")); -} - -void tst_qregexp::horribleWrongReplace2() -{ - QString r; - QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*"); - rx.setPatternSyntax(QRegExp::RegExp2); - QBENCHMARK{ - r = QString(str2).replace(rx, "\\1.\\2.\\3"); - } - QCOMPARE(r, str2); -} - -void tst_qregexp::horribleReplace2() -{ - QString r; - QRegExp rx(".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*"); - rx.setPatternSyntax(QRegExp::RegExp2); - QBENCHMARK{ - r = QString(str2).replace(rx, "\\1.\\2.\\3"); - } - QCOMPARE(r, QString("1.2.3")); -} -void tst_qregexp::simpleFindJSC() -{ -#ifdef HAVE_JSC - int numr; - const char * errmsg=" "; - QString rxs("happy"); - JSRegExp *rx = jsRegExpCompile(rxs.utf16(), rxs.length(), JSRegExpDoNotIgnoreCase, JSRegExpSingleLine, 0, &errmsg); - QVERIFY(rx != 0); - QString s(str1); - int offsetVector[3]; - QBENCHMARK{ - numr = jsRegExpExecute(rx, s.utf16(), s.length(), 0, offsetVector, 3); - } - jsRegExpFree(rx); - QCOMPARE(numr, 1); - QCOMPARE(offsetVector[0], 11); -#else - QSKIP("JSC is not enabled for this platform"); -#endif -} - -void tst_qregexp::rangeReplaceJSC() -{ -#ifdef HAVE_JSC - QScriptValue r; - QScriptEngine engine; - engine.globalObject().setProperty("s", str1); - QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/[a-f]/g, '-') } )"); - QVERIFY(replaceFunc.isFunction()); - QBENCHMARK{ - r = replaceFunc.call(QScriptValue()); - } - QCOMPARE(r.toString(), QString("W- -r- -ll h-ppy monk-ys")); -#else - QSKIP("JSC is not enabled for this platform"); -#endif -} - -void tst_qregexp::matchReplaceJSC() -{ -#ifdef HAVE_JSC - QScriptValue r; - QScriptEngine engine; - engine.globalObject().setProperty("s", str1); - QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/[^a-f]*([a-f]+)[^a-f]*/g, '$1') } )"); - QVERIFY(replaceFunc.isFunction()); - QBENCHMARK{ - r = replaceFunc.call(QScriptValue()); - } - QCOMPARE(r.toString(), QString("eaeaae")); -#else - QSKIP("JSC is not enabled for this platform"); -#endif -} - -void tst_qregexp::horribleWrongReplaceJSC() -{ -#ifdef HAVE_JSC - QScriptValue r; - QScriptEngine engine; - engine.globalObject().setProperty("s", str2); - QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/.*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*/gm, '$1.$2.$3') } )"); - QVERIFY(replaceFunc.isFunction()); - QBENCHMARK{ - r = replaceFunc.call(QScriptValue()); - } - QCOMPARE(r.toString(), str2); -#else - QSKIP("JSC is not enabled for this platform"); -#endif -} - -void tst_qregexp::horribleReplaceJSC() -{ -#ifdef HAVE_JSC - QScriptValue r; - QScriptEngine engine; - // the m flag doesn't actually work here; dunno - engine.globalObject().setProperty("s", str2.replace('\n', ' ')); - QScriptValue replaceFunc = engine.evaluate("(function() { return s.replace(/.*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*/gm, '$1.$2.$3') } )"); - QVERIFY(replaceFunc.isFunction()); - QBENCHMARK{ - r = replaceFunc.call(QScriptValue()); - } - QCOMPARE(r.toString(), QString("1.2.3")); -#else - QSKIP("JSC is not enabled for this platform"); -#endif -} - -void tst_qregexp::simpleFindBoost() -{ -#ifdef HAVE_BOOST - int roff; - boost::regex rx ("happy", boost::regex_constants::perl); - std::string s = str1.toStdString(); - std::string::const_iterator start, end; - start = s.begin(); - end = s.end(); - boost::match_flag_type flags = boost::match_default; - QBENCHMARK{ - boost::match_results what; - regex_search(start, end, what, rx, flags); - roff = (what[0].first)-start; - } - QCOMPARE(roff, 11); -#else - QSKIP("Boost is not enabled for this platform"); -#endif - -} - -void tst_qregexp::rangeReplaceBoost() -{ -#ifdef HAVE_BOOST - boost::regex pattern ("[a-f]", boost::regex_constants::perl); - std::string s = str1.toStdString(); - std::string r; - QBENCHMARK{ - r = boost::regex_replace (s, pattern, "-"); - } - QCOMPARE(r, std::string("W- -r- -ll h-ppy monk-ys")); -#else - QSKIP("Boost is not enabled for this platform"); -#endif -} - -void tst_qregexp::matchReplaceBoost() -{ -#ifdef HAVE_BOOST - boost::regex pattern ("[^a-f]*([a-f]+)[^a-f]*",boost::regex_constants::perl); - std::string s = str1.toStdString(); - std::string r; - QBENCHMARK{ - r = boost::regex_replace (s, pattern, "$1"); - } - QCOMPARE(r, std::string("eaeaae")); -#else - QSKIP("Boost is not enabled for this platform"); -#endif -} - -void tst_qregexp::horribleWrongReplaceBoost() -{ -#ifdef HAVE_BOOST - boost::regex pattern (".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+)\".*", boost::regex_constants::perl); - std::string s = str2.toStdString(); - std::string r; - QBENCHMARK{ - r = boost::regex_replace (s, pattern, "$1.$2.$3"); - } - QCOMPARE(r, s); -#else - QSKIP("Boost is not enabled for this platform"); -#endif -} - -void tst_qregexp::horribleReplaceBoost() -{ -#ifdef HAVE_BOOST - boost::regex pattern (".*#""define ZLIB_VERSION \"([0-9]+)\\.([0-9]+)\\.([0-9]+).*", boost::regex_constants::perl); - std::string s = str2.toStdString(); - std::string r; - QBENCHMARK{ - r = boost::regex_replace (s, pattern, "$1.$2.$3"); - } - QCOMPARE(r, std::string("1.2.3")); -#else - QSKIP("Boost is not enabled for this platform"); -#endif -} - -QTEST_MAIN(tst_qregexp) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qregexp/qregexp.pro b/tests/benchmarks/corelib/tools/qregexp/qregexp.pro deleted file mode 100644 index f64ae781a2..0000000000 --- a/tests/benchmarks/corelib/tools/qregexp/qregexp.pro +++ /dev/null @@ -1,20 +0,0 @@ -TEMPLATE = app -TARGET = tst_bench_qregexp -QT = core testlib -CONFIG += release exceptions - -SOURCES += main.cpp -RESOURCES += qregexp.qrc - -qtHaveModule(script):!pcre { - DEFINES += HAVE_JSC - QT += script -} - -!qnx { - exists($$[QT_SYSROOT]/usr/include/boost/regex.hpp) { - DEFINES += HAVE_BOOST - LIBS += -lboost_regex - } -} - diff --git a/tests/benchmarks/corelib/tools/qregexp/qregexp.qrc b/tests/benchmarks/corelib/tools/qregexp/qregexp.qrc deleted file mode 100644 index a7fe13c035..0000000000 --- a/tests/benchmarks/corelib/tools/qregexp/qregexp.qrc +++ /dev/null @@ -1,6 +0,0 @@ - - - main.cpp - - - diff --git a/tests/benchmarks/corelib/tools/qstring/main.cpp b/tests/benchmarks/corelib/tools/qstring/main.cpp deleted file mode 100644 index 826a843c10..0000000000 --- a/tests/benchmarks/corelib/tools/qstring/main.cpp +++ /dev/null @@ -1,193 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ -#include -#include -#include - -class tst_QString: public QObject -{ - Q_OBJECT -public: - tst_QString(); -private slots: - void section_regexp_data() { section_data_impl(); } - void section_regexp() { section_impl(); } - void section_regularexpression_data() { section_data_impl(); } - void section_regularexpression() { section_impl(); } - void section_string_data() { section_data_impl(false); } - void section_string() { section_impl(); } - - void toUpper_data(); - void toUpper(); - void toLower_data(); - void toLower(); - void toCaseFolded_data(); - void toCaseFolded(); - -private: - void section_data_impl(bool includeRegExOnly = true); - template void section_impl(); -}; - -tst_QString::tst_QString() -{ -} - -void tst_QString::section_data_impl(bool includeRegExOnly) -{ - QTest::addColumn("s"); - QTest::addColumn("sep"); - QTest::addColumn("isRegExp"); - - QTest::newRow("IPv4") << QStringLiteral("192.168.0.1") << QStringLiteral(".") << false; - QTest::newRow("IPv6") << QStringLiteral("2001:0db8:85a3:0000:0000:8a2e:0370:7334") << QStringLiteral(":") << false; - if (includeRegExOnly) { - QTest::newRow("IPv6-reversed-roles") << QStringLiteral("2001:0db8:85a3:0000:0000:8a2e:0370:7334") << QStringLiteral("\\d+") << true; - QTest::newRow("IPv6-complex") << QStringLiteral("2001:0db8:85a3:0000:0000:8a2e:0370:7334") << QStringLiteral("(\\d+):\\1") << true; - } -} - -template -inline QString escape(const QString &s) -{ return RX::escape(s); } - -template <> -inline QString escape(const QString &s) -{ return s; } - -template -inline void optimize(RX &) {} - -template <> -inline void optimize(QRegularExpression &rx) -{ rx.optimize(); } - -template -void tst_QString::section_impl() -{ - QFETCH(QString, s); - QFETCH(QString, sep); - QFETCH(bool, isRegExp); - - RX rx(isRegExp ? sep : escape(sep)); - optimize(rx); - for (int i = 0; i < 20; ++i) - (void) s.count(rx); // make (s, rx) hot - - QBENCHMARK { - const QString result = s.section(rx, 0, 16); - Q_UNUSED(result); - } -} - -void tst_QString::toUpper_data() -{ - QTest::addColumn("s"); - - QString lowerLatin1(300, QChar('a')); - QString upperLatin1(300, QChar('A')); - - QString lowerDeseret; - { - QString pattern; - pattern += QChar(QChar::highSurrogate(0x10428)); - pattern += QChar(QChar::lowSurrogate(0x10428)); - for (int i = 0; i < 300 / pattern.size(); ++i) - lowerDeseret += pattern; - } - QString upperDeseret; - { - QString pattern; - pattern += QChar(QChar::highSurrogate(0x10400)); - pattern += QChar(QChar::lowSurrogate(0x10400)); - for (int i = 0; i < 300 / pattern.size(); ++i) - upperDeseret += pattern; - } - - QString lowerLigature(600, QChar(0xFB03)); - - QTest::newRow("600") << (lowerLatin1 + lowerLatin1); - QTest::newRow("600") << (upperLatin1 + upperLatin1); - - QTest::newRow("300+300") << (lowerLatin1 + upperLatin1); - QTest::newRow("300+300") << (upperLatin1 + lowerLatin1); - - QTest::newRow("300<10428>") << (lowerDeseret + lowerDeseret); - QTest::newRow("300<10400>") << (upperDeseret + upperDeseret); - - QTest::newRow("150<10428>+150<10400>") << (lowerDeseret + upperDeseret); - QTest::newRow("150<10400>+150<10428>") << (upperDeseret + lowerDeseret); - - QTest::newRow("300a+150<10400>") << (lowerLatin1 + upperDeseret); - QTest::newRow("300a+150<10428>") << (lowerLatin1 + lowerDeseret); - QTest::newRow("300A+150<10400>") << (upperLatin1 + upperDeseret); - QTest::newRow("300A+150<10428>") << (upperLatin1 + lowerDeseret); - - QTest::newRow("600 (ligature)") << lowerLigature; -} - -void tst_QString::toUpper() -{ - QFETCH(QString, s); - - QBENCHMARK { - s.toUpper(); - } -} - -void tst_QString::toLower_data() -{ - toUpper_data(); -} - -void tst_QString::toLower() -{ - QFETCH(QString, s); - - QBENCHMARK { - s.toLower(); - } -} - -void tst_QString::toCaseFolded_data() -{ - toUpper_data(); -} - -void tst_QString::toCaseFolded() -{ - QFETCH(QString, s); - - QBENCHMARK { - s.toCaseFolded(); - } -} - -QTEST_APPLESS_MAIN(tst_QString) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qstring/qstring.pro b/tests/benchmarks/corelib/tools/qstring/qstring.pro deleted file mode 100644 index 9f5e34b915..0000000000 --- a/tests/benchmarks/corelib/tools/qstring/qstring.pro +++ /dev/null @@ -1,5 +0,0 @@ -TARGET = tst_bench_qstring -QT -= gui -QT += core testlib -SOURCES += main.cpp - diff --git a/tests/benchmarks/corelib/tools/qstringbuilder/main.cpp b/tests/benchmarks/corelib/tools/qstringbuilder/main.cpp deleted file mode 100644 index 0de6d33846..0000000000 --- a/tests/benchmarks/corelib/tools/qstringbuilder/main.cpp +++ /dev/null @@ -1,420 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -// Select one of the scenarios below -#define SCENARIO 1 - -#if SCENARIO == 1 -// this is the "no harm done" version. Only operator% is active, -// with NO_CAST * defined -#define P % -#undef QT_USE_FAST_OPERATOR_PLUS -#undef QT_USE_FAST_CONCATENATION -#define QT_NO_CAST_FROM_ASCII -#define QT_NO_CAST_TO_ASCII -#endif - - -#if SCENARIO == 2 -// this is the "full" version. Operator+ is replaced by a QStringBuilder -// based version -// with NO_CAST * defined -#define P + -#define QT_USE_FAST_OPERATOR_PLUS -#define QT_USE_FAST_CONCATENATION -#define QT_NO_CAST_FROM_ASCII -#define QT_NO_CAST_TO_ASCII -#endif - -#if SCENARIO == 3 -// this is the "no harm done" version. Only operator% is active, -// with NO_CAST * _not_ defined -#define P % -#undef QT_USE_FAST_OPERATOR_PLUS -#undef QT_USE_FAST_CONCATENATION -#undef QT_NO_CAST_FROM_ASCII -#undef QT_NO_CAST_TO_ASCII -#endif - -#if SCENARIO == 4 -// this is the "full" version. Operator+ is replaced by a QStringBuilder -// based version -// with NO_CAST * _not_ defined -#define P + -#define QT_USE_FAST_OPERATOR_PLUS -#define QT_USE_FAST_CONCATENATION -#undef QT_NO_CAST_FROM_ASCII -#undef QT_NO_CAST_TO_ASCII -#endif - - -#include -#include -#include -#include - -#include - -#include - -#define COMPARE(a, b) QCOMPARE(a, b) -//#define COMPARE(a, b) - -#define SEP(s) qDebug() << "\n\n-------- " s " ---------"; - -#define LITERAL "some string literal" - -class tst_qstringbuilder : public QObject -{ - Q_OBJECT - -public: - tst_qstringbuilder() - : l1literal(LITERAL), - l1string(LITERAL), - ba(LITERAL), - string(l1string), - stdstring(LITERAL), - stringref(&string, 2, 10), - achar('c'), - r2(QLatin1String(LITERAL LITERAL)), - r3(QLatin1String(LITERAL LITERAL LITERAL)), - r4(QLatin1String(LITERAL LITERAL LITERAL LITERAL)), - r5(QLatin1String(LITERAL LITERAL LITERAL LITERAL LITERAL)) - {} - - -public: - enum { N = 10000 }; - - int run_traditional() - { - int s = 0; - for (int i = 0; i < N; ++i) { -#if 0 - s += QString(l1string + l1string).size(); - s += QString(l1string + l1string + l1string).size(); - s += QString(l1string + l1string + l1string + l1string).size(); - s += QString(l1string + l1string + l1string + l1string + l1string).size(); -#endif - s += QString(achar + l1string + achar).size(); - } - return s; - } - - int run_builder() - { - int s = 0; - for (int i = 0; i < N; ++i) { -#if 0 - s += QString(l1literal P l1literal).size(); - s += QString(l1literal P l1literal P l1literal).size(); - s += QString(l1literal P l1literal P l1literal P l1literal).size(); - s += QString(l1literal P l1literal P l1literal P l1literal P l1literal).size(); -#endif - s += QString(achar % l1literal % achar).size(); - } - return s; - } - -private slots: - - void separator_0() { - qDebug() << "\nIn each block the QStringBuilder based result appear first " - "(with a 'b_' prefix), QStringBased second ('q_' prefix), std::string " - "last ('s_' prefix)\n"; - } - - void separator_1() { SEP("literal + literal (builder first)"); } - - void b_2_l1literal() { - QBENCHMARK { r = l1literal P l1literal; } - COMPARE(r, r2); - } - #ifndef QT_NO_CAST_FROM_ASCII - void b_l1literal_LITERAL() { - QBENCHMARK { r = l1literal P LITERAL; } - COMPARE(r, r2); - } - #endif - void q_2_l1string() { - QBENCHMARK { r = l1string + l1string; } - COMPARE(r, r2); - } - - - void separator_2() { SEP("2 strings"); } - - void b_2_string() { - QBENCHMARK { r = string P string; } - COMPARE(r, r2); - } - void q_2_string() { - QBENCHMARK { r = string + string; } - COMPARE(r, r2); - } - void s_2_string() { - QBENCHMARK { stdr = stdstring + stdstring; } - COMPARE(stdr, stdstring + stdstring); - } - - - void separator_2c() { SEP("2 string refs"); } - - void b_2_stringref() { - QBENCHMARK { r = stringref % stringref; } - COMPARE(r, QString(stringref.toString() + stringref.toString())); - } - void q_2_stringref() { - QBENCHMARK { r = stringref.toString() + stringref.toString(); } - COMPARE(r, QString(stringref % stringref)); - } - - - void separator_2b() { SEP("3 strings"); } - - void b_3_string() { - QBENCHMARK { r = string P string P string; } - COMPARE(r, r3); - } - void q_3_string() { - QBENCHMARK { r = string + string + string; } - COMPARE(r, r3); - } - void s_3_string() { - QBENCHMARK { stdr = stdstring + stdstring + stdstring; } - COMPARE(stdr, stdstring + stdstring + stdstring); - } - - void separator_2e() { SEP("4 strings"); } - - void b_4_string() { - QBENCHMARK { r = string P string P string P string; } - COMPARE(r, r4); - } - void q_4_string() { - QBENCHMARK { r = string + string + string + string; } - COMPARE(r, r4); - } - void s_4_string() { - QBENCHMARK { stdr = stdstring + stdstring + stdstring + stdstring; } - COMPARE(stdr, stdstring + stdstring + stdstring + stdstring); - } - - - - void separator_2a() { SEP("string + literal (builder first)"); } - - void b_string_l1literal() { - QBENCHMARK { r = string % l1literal; } - COMPARE(r, r2); - } - #ifndef QT_NO_CAST_FROM_ASCII - void b_string_LITERAL() { - QBENCHMARK { r = string P LITERAL; } - COMPARE(r, r2); - } - void b_LITERAL_string() { - QBENCHMARK { r = LITERAL P string; } - COMPARE(r, r2); - } - #endif - void b_string_l1string() { - QBENCHMARK { r = string P l1string; } - COMPARE(r, r2); - } - void q_string_l1literal() { - QBENCHMARK { r = string + l1string; } - COMPARE(r, r2); - } - void q_string_l1string() { - QBENCHMARK { r = string + l1string; } - COMPARE(r, r2); - } - void s_LITERAL_string() { - QBENCHMARK { stdr = LITERAL + stdstring; } - COMPARE(stdr, stdstring + stdstring); - } - - - void separator_3() { SEP("3 literals"); } - - void b_3_l1literal() { - QBENCHMARK { r = l1literal P l1literal P l1literal; } - COMPARE(r, r3); - } - void q_3_l1string() { - QBENCHMARK { r = l1string + l1string + l1string; } - COMPARE(r, r3); - } - void s_3_l1string() { - QBENCHMARK { stdr = stdstring + LITERAL + LITERAL; } - COMPARE(stdr, stdstring + stdstring + stdstring); - } - - - void separator_4() { SEP("4 literals"); } - - void b_4_l1literal() { - QBENCHMARK { r = l1literal P l1literal P l1literal P l1literal; } - COMPARE(r, r4); - } - void q_4_l1string() { - QBENCHMARK { r = l1string + l1string + l1string + l1string; } - COMPARE(r, r4); - } - - - void separator_5() { SEP("5 literals"); } - - void b_5_l1literal() { - QBENCHMARK { r = l1literal P l1literal P l1literal P l1literal P l1literal; } - COMPARE(r, r5); - } - - void q_5_l1string() { - QBENCHMARK { r = l1string + l1string + l1string + l1string + l1string; } - COMPARE(r, r5); - } - - - void separator_6() { SEP("4 chars"); } - - void b_string_4_char() { - QBENCHMARK { r = string + achar + achar + achar + achar; } - COMPARE(r, QString(string P achar P achar P achar P achar)); - } - - void q_string_4_char() { - QBENCHMARK { r = string + achar + achar + achar + achar; } - COMPARE(r, QString(string P achar P achar P achar P achar)); - } - - void s_string_4_char() { - QBENCHMARK { stdr = stdstring + 'c' + 'c' + 'c' + 'c'; } - COMPARE(stdr, stdstring + 'c' + 'c' + 'c' + 'c'); - } - - - void separator_7() { SEP("char + string + char"); } - - void b_char_string_char() { - QBENCHMARK { r = achar + string + achar; } - COMPARE(r, QString(achar P string P achar)); - } - - void q_char_string_char() { - QBENCHMARK { r = achar + string + achar; } - COMPARE(r, QString(achar P string P achar)); - } - - void s_char_string_char() { - QBENCHMARK { stdr = 'c' + stdstring + 'c'; } - COMPARE(stdr, 'c' + stdstring + 'c'); - } - - - void separator_8() { SEP("string.arg"); } - - void b_string_arg() { - const QString pattern = l1string + QString::fromLatin1("%1") + l1string; - QBENCHMARK { r = l1literal P string P l1literal; } - COMPARE(r, r3); - } - - void q_string_arg() { - const QString pattern = l1string + QLatin1String("%1") + l1string; - QBENCHMARK { r = pattern.arg(string); } - COMPARE(r, r3); - } - - void q_bytearray_arg() { - QByteArray result; - QBENCHMARK { result = ba + ba + ba; } - } - - - void separator_9() { SEP("QString::reserve()"); } - - void b_reserve() { - QBENCHMARK { - r.clear(); - r = string P string P string P string; - } - COMPARE(r, r4); - } - void b_reserve_lit() { - QBENCHMARK { - r.clear(); - r = string P l1literal P string P string; - } - COMPARE(r, r4); - } - void s_reserve() { - QBENCHMARK { - r.clear(); - r.reserve(string.size() + string.size() + string.size() + string.size()); - r += string; - r += string; - r += string; - r += string; - } - COMPARE(r, r4); - } - void s_reserve_lit() { - QBENCHMARK { - r.clear(); - //r.reserve(string.size() + qstrlen(l1string.latin1()) - // + string.size() + string.size()); - r.reserve(1024); - r += string; - r += l1string; - r += string; - r += string; - } - COMPARE(r, r4); - } - -private: - const QLatin1String l1literal; - const QLatin1String l1string; - const QByteArray ba; - const QString string; - const std::string stdstring; - const QStringRef stringref; - const QLatin1Char achar; - const QString r2, r3, r4, r5; - - // short cuts for results - QString r; - std::string stdr; -}; - -QTEST_MAIN(tst_qstringbuilder) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qstringbuilder/qstringbuilder.pro b/tests/benchmarks/corelib/tools/qstringbuilder/qstringbuilder.pro deleted file mode 100644 index fa4cbe3c13..0000000000 --- a/tests/benchmarks/corelib/tools/qstringbuilder/qstringbuilder.pro +++ /dev/null @@ -1,11 +0,0 @@ -TEMPLATE = app -TARGET = tst_bench_qstringbuilder - -QMAKE_CXXFLAGS += -g -QMAKE_CFLAGS += -g - -QT = core testlib - -CONFIG += release - -SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/tools/qstringlist/.gitignore b/tests/benchmarks/corelib/tools/qstringlist/.gitignore deleted file mode 100644 index 3e0cdc952f..0000000000 --- a/tests/benchmarks/corelib/tools/qstringlist/.gitignore +++ /dev/null @@ -1 +0,0 @@ -tst_qstringlist diff --git a/tests/benchmarks/corelib/tools/qstringlist/main.cpp b/tests/benchmarks/corelib/tools/qstringlist/main.cpp deleted file mode 100644 index ae355a8b89..0000000000 --- a/tests/benchmarks/corelib/tools/qstringlist/main.cpp +++ /dev/null @@ -1,201 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include -#include - -#include -#include -#include - -class tst_QStringList: public QObject -{ - Q_OBJECT - -private slots: - void join() const; - void join_data() const; - - void split_qlist_qbytearray() const; - void split_qlist_qbytearray_data() const { return split_data(); } - - void split_data() const; - void split_qlist_qstring() const; - void split_qlist_qstring_data() const { return split_data(); } - - void split_stdvector_stdstring() const; - void split_stdvector_stdstring_data() const { return split_data(); } - - void split_stdvector_stdwstring() const; - void split_stdvector_stdwstring_data() const { return split_data(); } - - void split_stdlist_stdstring() const; - void split_stdlist_stdstring_data() const { return split_data(); } - -private: - static QStringList populateList(const int count, const QString &unit); - static QString populateString(const int count, const QString &unit); -}; - -QStringList tst_QStringList::populateList(const int count, const QString &unit) -{ - QStringList retval; - - for (int i = 0; i < count; ++i) - retval.append(unit); - - return retval; -} - -QString tst_QStringList::populateString(const int count, const QString &unit) -{ - QString retval; - - for (int i = 0; i < count; ++i) { - retval.append(unit); - retval.append(QLatin1Char(':')); - } - - return retval; -} - -void tst_QStringList::join() const -{ - QFETCH(QStringList, input); - QFETCH(QString, separator); - - QBENCHMARK { - input.join(separator); - } -} - -void tst_QStringList::join_data() const -{ - QTest::addColumn("input"); - QTest::addColumn("separator"); - - QTest::newRow("") - << populateList(100, QLatin1String("unit")) - << QString(); - - QTest::newRow("") - << populateList(1000, QLatin1String("unit")) - << QString(); - - QTest::newRow("") - << populateList(10000, QLatin1String("unit")) - << QString(); - - QTest::newRow("") - << populateList(100000, QLatin1String("unit")) - << QString(); -} - -void tst_QStringList::split_data() const -{ - QTest::addColumn("input"); - QString unit = QLatin1String("unit") + QString(100, QLatin1Char('s')); - //QTest::newRow("") << populateString(10, unit); - QTest::newRow("") << populateString(100, unit); - //QTest::newRow("") << populateString(100, unit); - //QTest::newRow("") << populateString(1000, unit); - //QTest::newRow("") << populateString(10000, unit); -} - -void tst_QStringList::split_qlist_qbytearray() const -{ - QFETCH(QString, input); - const char splitChar = ':'; - QByteArray ba = input.toLatin1(); - - QBENCHMARK { - ba.split(splitChar); - } -} - -void tst_QStringList::split_qlist_qstring() const -{ - QFETCH(QString, input); - const QChar splitChar = ':'; - - QBENCHMARK { - input.split(splitChar); - } -} - -void tst_QStringList::split_stdvector_stdstring() const -{ - QFETCH(QString, input); - const char split_char = ':'; - std::string stdinput = input.toStdString(); - - QBENCHMARK { - std::istringstream split(stdinput); - std::vector token; - for (std::string each; - std::getline(split, each, split_char); - token.push_back(each)) - ; - } -} - -void tst_QStringList::split_stdvector_stdwstring() const -{ - QFETCH(QString, input); - const wchar_t split_char = ':'; - std::wstring stdinput = input.toStdWString(); - - QBENCHMARK { - std::wistringstream split(stdinput); - std::vector token; - for (std::wstring each; - std::getline(split, each, split_char); - token.push_back(each)) - ; - } -} - -void tst_QStringList::split_stdlist_stdstring() const -{ - QFETCH(QString, input); - const char split_char = ':'; - std::string stdinput = input.toStdString(); - - QBENCHMARK { - std::istringstream split(stdinput); - std::list token; - for (std::string each; - std::getline(split, each, split_char); - token.push_back(each)) - ; - } -} - -QTEST_MAIN(tst_QStringList) - -#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qstringlist/qstringlist.pro b/tests/benchmarks/corelib/tools/qstringlist/qstringlist.pro deleted file mode 100644 index 5803e7da0e..0000000000 --- a/tests/benchmarks/corelib/tools/qstringlist/qstringlist.pro +++ /dev/null @@ -1,5 +0,0 @@ -TARGET = tst_bench_qstringlist -CONFIG -= debug -CONFIG += release -QT = core testlib -SOURCES += main.cpp diff --git a/tests/benchmarks/corelib/tools/tools.pro b/tests/benchmarks/corelib/tools/tools.pro index 33cbe00438..b4ee0520a6 100644 --- a/tests/benchmarks/corelib/tools/tools.pro +++ b/tests/benchmarks/corelib/tools/tools.pro @@ -2,19 +2,12 @@ TEMPLATE = subdirs SUBDIRS = \ containers-associative \ containers-sequential \ - qbytearray \ qcontiguouscache \ qcryptographichash \ qlist \ - qlocale \ qmap \ qrect \ qringbuffer \ qstack \ - qstring \ - qstringbuilder \ - qstringlist \ qvector \ qalgorithms - -!*g++*: SUBDIRS -= qstring -- cgit v1.2.3 From 2f33e030b8c80b4665cc2c120df7833469c05145 Mon Sep 17 00:00:00 2001 From: Sona Kurazyan Date: Wed, 10 Jul 2019 17:04:42 +0200 Subject: Remove usages of deprecated APIs of qtbase/gui - Replaced the usages of deprecated APIs by corresponding alternatives in the library code and documentation. - Modified the tests to make them build when deprecated APIs disabled: * Made the the parts of the tests testing the deprecated APIs to be compiled conditionally, only when the corresponding methods are enabled. * If the test-case tests only the deprecated API, but not the corresponding replacement, added tests for the replacement. Change-Id: Ic38245015377fc0c8127eb5458c184ffd4b450f1 Reviewed-by: Volker Hilsheimer --- tests/benchmarks/gui/image/qpixmapcache/tst_qpixmapcache.cpp | 4 ++-- .../qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp | 2 +- .../widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp | 2 +- .../widgets/graphicsview/qgraphicsview/chiptester/chip.cpp | 6 +++--- 4 files changed, 7 insertions(+), 7 deletions(-) (limited to 'tests/benchmarks') diff --git a/tests/benchmarks/gui/image/qpixmapcache/tst_qpixmapcache.cpp b/tests/benchmarks/gui/image/qpixmapcache/tst_qpixmapcache.cpp index d4be85b5ad..2ded426cdd 100644 --- a/tests/benchmarks/gui/image/qpixmapcache/tst_qpixmapcache.cpp +++ b/tests/benchmarks/gui/image/qpixmapcache/tst_qpixmapcache.cpp @@ -106,7 +106,7 @@ void tst_QPixmapCache::find() if (cacheType) { QBENCHMARK { for (int i = 0 ; i <= 10000 ; i++) - QPixmapCache::find(QString::asprintf("my-key-%d", i), p); + QPixmapCache::find(QString::asprintf("my-key-%d", i), &p); } } else { QBENCHMARK { @@ -155,7 +155,7 @@ void tst_QPixmapCache::styleUseCaseComplexKey() QPixmapCache::insert(QString::asprintf("%s-%d-%d-%d-%d-%d-%d", QString("my-progressbar-%1").arg(i).toLatin1().constData(), 5, 3, 0, 358, 100, 200), p); for (int i = 0 ; i <= 10000 ; i++) - QPixmapCache::find(QString::asprintf("%s-%d-%d-%d-%d-%d-%d", QString("my-progressbar-%1").arg(i).toLatin1().constData(), 5, 3, 0, 358, 100, 200), p); + QPixmapCache::find(QString::asprintf("%s-%d-%d-%d-%d-%d-%d", QString("my-progressbar-%1").arg(i).toLatin1().constData(), 5, 3, 0, 358, 100, 200), &p); } } else { QHash hash; diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp index b15aad04cd..e0c5a7f683 100644 --- a/tests/benchmarks/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp +++ b/tests/benchmarks/widgets/graphicsview/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp @@ -60,7 +60,7 @@ public: { Q_UNUSED(option); Q_UNUSED(widget); - painter->drawRoundRect(rect()); + painter->drawRoundedRect(rect(), 25, 25, Qt::RelativeSize); painter->drawLine(rect().topLeft(), rect().bottomRight()); painter->drawLine(rect().bottomLeft(), rect().topRight()); } diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp index 5c97d7f738..caf5455a80 100644 --- a/tests/benchmarks/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp +++ b/tests/benchmarks/widgets/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp @@ -53,7 +53,7 @@ public: { Q_UNUSED(option); Q_UNUSED(widget); - painter->drawRoundRect(rect()); + painter->drawRoundedRect(rect(), 25, 25, Qt::RelativeSize); painter->drawLine(rect().topLeft(), rect().bottomRight()); painter->drawLine(rect().bottomLeft(), rect().topRight()); } diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicsview/chiptester/chip.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicsview/chiptester/chip.cpp index cf82282bfe..21eb622f15 100644 --- a/tests/benchmarks/widgets/graphicsview/qgraphicsview/chiptester/chip.cpp +++ b/tests/benchmarks/widgets/graphicsview/qgraphicsview/chiptester/chip.cpp @@ -57,9 +57,9 @@ void Chip::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWid { Q_UNUSED(widget); - QColor fillColor = (option->state & QStyle::State_Selected) ? color.dark(150) : color; + QColor fillColor = (option->state & QStyle::State_Selected) ? color.darker(150) : color; if (option->state & QStyle::State_MouseOver) - fillColor = fillColor.light(125); + fillColor = fillColor.lighter(125); if (option->levelOfDetail < 0.2) { if (option->levelOfDetail < 0.125) { @@ -82,7 +82,7 @@ void Chip::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWid pen.setWidth(width); QBrush b = painter->brush(); - painter->setBrush(QBrush(fillColor.dark(option->state & QStyle::State_Sunken ? 120 : 100))); + painter->setBrush(QBrush(fillColor.darker(option->state & QStyle::State_Sunken ? 120 : 100))); painter->drawRect(QRect(14, 14, 79, 39)); painter->setBrush(b); -- cgit v1.2.3 From c21cc647e98327856006701ee59b798ef2723e85 Mon Sep 17 00:00:00 2001 From: Allan Sandfeld Jensen Date: Mon, 22 Jul 2019 14:00:20 +0200 Subject: Fix lancebench results oddness Imports were expanded in the list of commands every time they were evaluated. This meant any test with imports ran slower and slower the more iterations it got through. Fixed by creating a new PaintCommands object every time and living with initialization of it being part of the benchmark results. Change-Id: Ib53a3a25f1393437452bc5aede04ccb63e8715a6 Reviewed-by: Eirik Aavitsland --- .../gui/painting/lancebench/tst_lancebench.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'tests/benchmarks') diff --git a/tests/benchmarks/gui/painting/lancebench/tst_lancebench.cpp b/tests/benchmarks/gui/painting/lancebench/tst_lancebench.cpp index bd0889bf4a..d26ac016b9 100644 --- a/tests/benchmarks/gui/painting/lancebench/tst_lancebench.cpp +++ b/tests/benchmarks/gui/painting/lancebench/tst_lancebench.cpp @@ -305,17 +305,17 @@ void tst_LanceBench::runTestSuite(GraphicsEngine engine, QImage::Format format, void tst_LanceBench::paint(QPaintDevice *device, GraphicsEngine engine, QImage::Format format, const QStringList &script, const QString &filePath) { - PaintCommands pcmd(script, 800, 800, format); - switch (engine) { - case OpenGL: - pcmd.setType(OpenGLBufferType); // version/profile is communicated through the context's format() - break; - case Raster: - pcmd.setType(ImageType); - break; - } - pcmd.setFilePath(filePath); QBENCHMARK { + PaintCommands pcmd(script, 800, 800, format); + switch (engine) { + case OpenGL: + pcmd.setType(OpenGLBufferType); // version/profile is communicated through the context's format() + break; + case Raster: + pcmd.setType(ImageType); + break; + } + pcmd.setFilePath(filePath); QPainter p(device); pcmd.setPainter(&p); pcmd.runCommands(); -- cgit v1.2.3 From ca5fc087bdc94fad14f8edce89cfe171858260dc Mon Sep 17 00:00:00 2001 From: Marc Mutz Date: Tue, 23 Jul 2019 22:14:50 +0300 Subject: Re-apply 'Skip old benchmark that doesn't build automatically' MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit re-applies commit f8efe8e0c91905d5077131d343f2ae2b3ca7daa2, which was lost in the recent tools → text changes. Change-Id: I03ce35fcb89840e5607776d67578fb75b66f6eb2 Reviewed-by: Allan Sandfeld Jensen --- tests/benchmarks/corelib/text/text.pro | 1 - 1 file changed, 1 deletion(-) (limited to 'tests/benchmarks') diff --git a/tests/benchmarks/corelib/text/text.pro b/tests/benchmarks/corelib/text/text.pro index 8c15d0b0c5..a2397b37fe 100644 --- a/tests/benchmarks/corelib/text/text.pro +++ b/tests/benchmarks/corelib/text/text.pro @@ -3,7 +3,6 @@ SUBDIRS = \ qbytearray \ qchar \ qlocale \ - qregexp \ qstringbuilder \ qstringlist -- cgit v1.2.3 From 376715f1a57209cbb19502954a37939e2d6d88c6 Mon Sep 17 00:00:00 2001 From: Sona Kurazyan Date: Tue, 23 Jul 2019 15:26:19 +0200 Subject: Remove usages of deprecated APIs of qtbase/widgets - Replace the usages of deprecated APIs by corresponding alternatives in the library code and documentation. - Build docs for deprecated APIs conditionally, based on deprecation version. Remove the docs of methods deprecated since 5.0.0, these methods are not compiled anymore. - Modify the tests to make them build when deprecated APIs disabled: * Make the the parts of the tests testing the deprecated APIs to be compiled conditionally, only when the corresponding methods are enabled. * If the test-case tests only the deprecated API, but not the corresponding replacement, add tests for the replacement Task-number: QTBUG-76491 Task-number: QTBUG-76540 Task-number: QTBUG-76541 Change-Id: I6aaf0a1369c479fb880369a38f2b8e1e86b46934 Reviewed-by: Volker Hilsheimer --- .../widgets/graphicsview/qgraphicsview/benchapps/chipTest/chip.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tests/benchmarks') diff --git a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/chip.cpp b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/chip.cpp index 57ab62b1c3..2277ae0f14 100644 --- a/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/chip.cpp +++ b/tests/benchmarks/widgets/graphicsview/qgraphicsview/benchapps/chipTest/chip.cpp @@ -38,7 +38,7 @@ Chip::Chip(const QColor &color, int x, int y) setZValue((x + y) % 2); setFlags(ItemIsSelectable | ItemIsMovable); - setAcceptsHoverEvents(true); + setAcceptHoverEvents(true); } QRectF Chip::boundingRect() const -- cgit v1.2.3