diff options
Diffstat (limited to 'tests/auto/corelib/tools')
5 files changed, 395 insertions, 36 deletions
diff --git a/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp b/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp index 6961426f59..bde9433a24 100644 --- a/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp +++ b/tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp @@ -50,6 +50,8 @@ private Q_SLOTS: void qthash(); void range(); void rangeCommutative(); + + void setGlobalQHashSeed(); }; void tst_QHashFunctions::qhash() @@ -207,5 +209,21 @@ void tst_QHashFunctions::rangeCommutative() (void)qHashRangeCommutative(hashables, hashables + numHashables); } +void tst_QHashFunctions::setGlobalQHashSeed() +{ + // Setter works as advertised + qSetGlobalQHashSeed(0x10101010); + QCOMPARE(qGlobalQHashSeed(), 0x10101010); + + // Creating a new QHash doesn't reset the seed + QHash<QString, int> someHash; + someHash.insert("foo", 42); + QCOMPARE(qGlobalQHashSeed(), 0x10101010); + + // Reset works as advertised + qSetGlobalQHashSeed(-1); + QVERIFY(qGlobalQHashSeed() != -1); +} + QTEST_APPLESS_MAIN(tst_QHashFunctions) #include "tst_qhashfunctions.moc" diff --git a/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.cpp b/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.cpp index 6b7614b7b9..8ddd4979b6 100644 --- a/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.cpp +++ b/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.cpp @@ -1,7 +1,7 @@ /**************************************************************************** ** -** Copyright (C) 2012 Giuseppe D'Angelo <dangelog@gmail.com>. -** Copyright (C) 2013 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com> +** Copyright (C) 2015 Giuseppe D'Angelo <dangelog@gmail.com>. +** Copyright (C) 2015 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com> ** Contact: http://www.qt.io/licensing/ ** ** This file is part of the test suite of the Qt Toolkit. @@ -306,19 +306,6 @@ static void testMatch(const QRegularExpression ®exp, matchType, matchOptions, result); - - // offset <= 0 tested above; now also test stringrefs not spanning over - // the entire subject. Note that the offset can be negative, hence the above - // tests can't be merged into this one - for (int i = 1; i <= offset; ++i) { - testMatchImpl<QREMatch>(regexp, - matchingMethodForStringRef, - QStringRef(&subject, i, subject.length() - i), - offset - i, - matchType, - matchOptions, - result); - } } typedef QRegularExpressionMatch (QRegularExpression::*QREMatchStringPMF)(const QString &, int, QRegularExpression::MatchType, QRegularExpression::MatchOptions) const; @@ -737,6 +724,18 @@ void tst_QRegularExpression::normalMatch_data() // *** m.clear(); + m.isValid = true; m.hasMatch = true; + m.captured << "bcd"; + QTest::newRow("match12") + << QRegularExpression("\\Bbcd\\B") + << "abcde" + << 1 + << QRegularExpression::MatchOptions(QRegularExpression::NoMatchOption) + << m; + + // *** + + m.clear(); m.isValid = true; QTest::newRow("nomatch01") << QRegularExpression("\\d+") << "a string" @@ -1710,3 +1709,360 @@ void tst_QRegularExpression::JOptionUsage() re.optimize(); QCOMPARE(re.isValid(), isValid); } + +void tst_QRegularExpression::QStringAndQStringRefEquivalence() +{ + const QString subject = QStringLiteral("Mississippi"); + { + const QRegularExpression re("\\Biss\\B"); + QVERIFY(re.isValid()); + { + const QRegularExpressionMatch match = re.match(subject); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 1); + QCOMPARE(match.capturedEnd(), 4); + } + { + const QRegularExpressionMatch match = re.match(QStringRef(&subject)); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 1); + QCOMPARE(match.capturedEnd(), 4); + } + { + const QRegularExpressionMatch match = re.match(subject, 1); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 1); + QCOMPARE(match.capturedEnd(), 4); + } + { + const QRegularExpressionMatch match = re.match(QStringRef(&subject), 1); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 1); + QCOMPARE(match.capturedEnd(), 4); + } + { + const QRegularExpressionMatch match = re.match(subject.mid(1)); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + } + { + const QRegularExpressionMatch match = re.match(subject.midRef(1)); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + } + { + const QRegularExpressionMatch match = re.match(subject.mid(1), 1); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + } + { + const QRegularExpressionMatch match = re.match(subject.midRef(1), 1); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + } + { + const QRegularExpressionMatch match = re.match(subject, 4); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 4); + QCOMPARE(match.capturedEnd(), 7); + } + { + const QRegularExpressionMatch match = re.match(QStringRef(&subject), 4); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 4); + QCOMPARE(match.capturedEnd(), 7); + } + { + const QRegularExpressionMatch match = re.match(subject.mid(4)); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(!match.hasMatch()); + } + { + const QRegularExpressionMatch match = re.match(subject.midRef(4)); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(!match.hasMatch()); + } + + { + QRegularExpressionMatchIterator i = re.globalMatch(subject); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match1 = i.next(); + consistencyCheck(match1); + QVERIFY(match1.isValid()); + QVERIFY(match1.hasMatch()); + QCOMPARE(match1.captured(), QStringLiteral("iss")); + QCOMPARE(match1.capturedStart(), 1); + QCOMPARE(match1.capturedEnd(), 4); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match2 = i.next(); + consistencyCheck(match2); + QVERIFY(match2.isValid()); + QVERIFY(match2.hasMatch()); + QCOMPARE(match2.captured(), QStringLiteral("iss")); + QCOMPARE(match2.capturedStart(), 4); + QCOMPARE(match2.capturedEnd(), 7); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(QStringRef(&subject)); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match1 = i.next(); + consistencyCheck(match1); + QVERIFY(match1.isValid()); + QVERIFY(match1.hasMatch()); + QCOMPARE(match1.captured(), QStringLiteral("iss")); + QCOMPARE(match1.capturedStart(), 1); + QCOMPARE(match1.capturedEnd(), 4); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match2 = i.next(); + consistencyCheck(match2); + QVERIFY(match2.isValid()); + QVERIFY(match2.hasMatch()); + QCOMPARE(match2.captured(), QStringLiteral("iss")); + QCOMPARE(match2.capturedStart(), 4); + QCOMPARE(match2.capturedEnd(), 7); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject, 1); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match1 = i.next(); + consistencyCheck(match1); + QVERIFY(match1.isValid()); + QVERIFY(match1.hasMatch()); + QCOMPARE(match1.captured(), QStringLiteral("iss")); + QCOMPARE(match1.capturedStart(), 1); + QCOMPARE(match1.capturedEnd(), 4); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match2 = i.next(); + consistencyCheck(match2); + QVERIFY(match2.isValid()); + QVERIFY(match2.hasMatch()); + QCOMPARE(match2.captured(), QStringLiteral("iss")); + QCOMPARE(match2.capturedStart(), 4); + QCOMPARE(match2.capturedEnd(), 7); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(QStringRef(&subject), 1); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match1 = i.next(); + consistencyCheck(match1); + QVERIFY(match1.isValid()); + QVERIFY(match1.hasMatch()); + QCOMPARE(match1.captured(), QStringLiteral("iss")); + QCOMPARE(match1.capturedStart(), 1); + QCOMPARE(match1.capturedEnd(), 4); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match2 = i.next(); + consistencyCheck(match2); + QVERIFY(match2.isValid()); + QVERIFY(match2.hasMatch()); + QCOMPARE(match2.captured(), QStringLiteral("iss")); + QCOMPARE(match2.capturedStart(), 4); + QCOMPARE(match2.capturedEnd(), 7); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.mid(1)); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.midRef(1)); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.mid(1), 1); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.midRef(1), 1); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.mid(1), 1); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.midRef(1), 1); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 3); + QCOMPARE(match.capturedEnd(), 6); + + QVERIFY(!i.hasNext()); + } + + { + QRegularExpressionMatchIterator i = re.globalMatch(subject, 4); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 4); + QCOMPARE(match.capturedEnd(), 7); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(QStringRef(&subject), 4); + QVERIFY(i.isValid()); + + consistencyCheck(i); + QVERIFY(i.hasNext()); + const QRegularExpressionMatch match = i.next(); + consistencyCheck(match); + QVERIFY(match.isValid()); + QVERIFY(match.hasMatch()); + QCOMPARE(match.captured(), QStringLiteral("iss")); + QCOMPARE(match.capturedStart(), 4); + QCOMPARE(match.capturedEnd(), 7); + + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.mid(4)); + consistencyCheck(i); + QVERIFY(i.isValid()); + QVERIFY(!i.hasNext()); + } + { + QRegularExpressionMatchIterator i = re.globalMatch(subject.midRef(4)); + consistencyCheck(i); + QVERIFY(i.isValid()); + QVERIFY(!i.hasNext()); + } + } +} diff --git a/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.h b/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.h index 578a4129ec..aed262d15d 100644 --- a/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.h +++ b/tests/auto/corelib/tools/qregularexpression/tst_qregularexpression.h @@ -72,6 +72,7 @@ private slots: void regularExpressionMatch(); void JOptionUsage_data(); void JOptionUsage(); + void QStringAndQStringRefEquivalence(); private: void provideRegularExpressions(); diff --git a/tests/auto/corelib/tools/qset/tst_qset.cpp b/tests/auto/corelib/tools/qset/tst_qset.cpp index ef0ebabd66..134d257d64 100644 --- a/tests/auto/corelib/tools/qset/tst_qset.cpp +++ b/tests/auto/corelib/tools/qset/tst_qset.cpp @@ -970,24 +970,6 @@ void tst_QSet::initializerList() #endif } -QT_BEGIN_NAMESPACE -extern Q_CORE_EXPORT QBasicAtomicInt qt_qhash_seed; // from qhash.cpp -QT_END_NAMESPACE - -class QtQHashSeedSaver { - int oldSeed, newSeed; -public: - explicit QtQHashSeedSaver(int seed) - : oldSeed(qt_qhash_seed.fetchAndStoreRelaxed(seed)), - newSeed(seed) - {} - ~QtQHashSeedSaver() - { - // only restore when no-one else changed the seed in the meantime: - qt_qhash_seed.testAndSetRelaxed(newSeed, oldSeed); - } -}; - void tst_QSet::qhash() { // @@ -995,14 +977,14 @@ void tst_QSet::qhash() // { // create some deterministic initial state: - const QtQHashSeedSaver seed1(0); + qSetGlobalQHashSeed(0); QSet<int> s1; s1.reserve(4); s1 << 400 << 300 << 200 << 100; // also change the seed: - const QtQHashSeedSaver seed2(0x10101010); + qSetGlobalQHashSeed(0x10101010); QSet<int> s2; s2.reserve(100); // provoke different bucket counts @@ -1049,7 +1031,7 @@ void tst_QSet::intersects() s1 << 200; QVERIFY(s1.intersects(s2)); - const QtQHashSeedSaver seedSaver(0x10101010); + qSetGlobalQHashSeed(0x10101010); QSet<int> s3; s3 << 500; QVERIFY(!s1.intersects(s3)); diff --git a/tests/auto/corelib/tools/qtime/tst_qtime.cpp b/tests/auto/corelib/tools/qtime/tst_qtime.cpp index 9a9101b7e9..213b817c3d 100644 --- a/tests/auto/corelib/tools/qtime/tst_qtime.cpp +++ b/tests/auto/corelib/tools/qtime/tst_qtime.cpp @@ -84,6 +84,8 @@ void tst_QTime::addSecs_data() QTest::newRow("Data0") << QTime(0,0,0) << 200 << QTime(0,3,20); QTest::newRow("Data1") << QTime(0,0,0) << 20 << QTime(0,0,20); + QTest::newRow("overflow") << QTime(0,0,0) << (INT_MAX / 1000 + 1) + << QTime(0,0,0).addSecs((INT_MAX / 1000 + 1) % 86400); } void tst_QTime::addSecs() |