diff options
Diffstat (limited to 'tests/auto/corelib/plugin/quuid')
6 files changed, 266 insertions, 53 deletions
diff --git a/tests/auto/corelib/plugin/quuid/CMakeLists.txt b/tests/auto/corelib/plugin/quuid/CMakeLists.txt index 216f2e8b6b..be90dc1849 100644 --- a/tests/auto/corelib/plugin/quuid/CMakeLists.txt +++ b/tests/auto/corelib/plugin/quuid/CMakeLists.txt @@ -1,7 +1,11 @@ # Copyright (C) 2022 The Qt Company Ltd. # SPDX-License-Identifier: BSD-3-Clause -# Generated from quuid.pro. +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_quuid LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() add_subdirectory(testProcessUniqueness) add_subdirectory(test) diff --git a/tests/auto/corelib/plugin/quuid/test/CMakeLists.txt b/tests/auto/corelib/plugin/quuid/test/CMakeLists.txt index 1e1e820b14..ec6c1979f7 100644 --- a/tests/auto/corelib/plugin/quuid/test/CMakeLists.txt +++ b/tests/auto/corelib/plugin/quuid/test/CMakeLists.txt @@ -9,6 +9,8 @@ qt_internal_add_test(tst_quuid OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/../" SOURCES ../tst_quuid.cpp + LIBRARIES + Qt::TestPrivate ) ## Scopes: diff --git a/tests/auto/corelib/plugin/quuid/testProcessUniqueness/CMakeLists.txt b/tests/auto/corelib/plugin/quuid/testProcessUniqueness/CMakeLists.txt index ea0fe6c1dc..f207cdaa3a 100644 --- a/tests/auto/corelib/plugin/quuid/testProcessUniqueness/CMakeLists.txt +++ b/tests/auto/corelib/plugin/quuid/testProcessUniqueness/CMakeLists.txt @@ -1,8 +1,6 @@ # Copyright (C) 2022 The Qt Company Ltd. # SPDX-License-Identifier: BSD-3-Clause -# Generated from testProcessUniqueness.pro. - ##################################################################### ## testProcessUniqueness Binary: ##################################################################### @@ -14,6 +12,4 @@ qt_internal_add_executable(testProcessUniqueness main.cpp ) -# special case begin set_target_properties(testProcessUniqueness PROPERTIES MACOSX_BUNDLE TRUE) -# special case end diff --git a/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp b/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp index 07109afabf..93d1201631 100644 --- a/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp +++ b/tests/auto/corelib/plugin/quuid/testProcessUniqueness/main.cpp @@ -1,5 +1,5 @@ // Copyright (C) 2016 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <stdio.h> #include <QUuid> diff --git a/tests/auto/corelib/plugin/quuid/tst_quuid.cpp b/tests/auto/corelib/plugin/quuid/tst_quuid.cpp index eb0ce46502..6d149c08db 100644 --- a/tests/auto/corelib/plugin/quuid/tst_quuid.cpp +++ b/tests/auto/corelib/plugin/quuid/tst_quuid.cpp @@ -1,8 +1,10 @@ // Copyright (C) 2016 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QTest> +#include <QtTest/private/qcomparisontesthelper_p.h> + #if QT_CONFIG(process) #include <QProcess> #endif @@ -17,6 +19,7 @@ class tst_QUuid : public QObject private slots: void initTestCase(); + void compareCompiles(); void fromChar(); void toString(); void fromString_data(); @@ -25,12 +28,16 @@ private slots: void fromByteArray(); void toRfc4122(); void fromRfc4122(); + void id128(); + void uint128(); void createUuidV3OrV5(); void check_QDataStream(); void isNull(); void equal(); void notEqual(); void cpp11(); + void ordering_data(); + void ordering(); // Only in Qt > 3.2.x void generate(); @@ -87,20 +94,28 @@ void tst_QUuid::initTestCase() uuidD = QUuid(0x21f7f8de, 0x8051, 0x5b89, 0x86, 0x80, 0x01, 0x95, 0xef, 0x79, 0x8b, 0x6a); } -void tst_QUuid::fromChar() +void tst_QUuid::compareCompiles() { - QCOMPARE(uuidA, QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}")); - QCOMPARE(uuidA, QUuid("fc69b59e-cc34-4436-a43c-ee95d128b8c5}")); - QCOMPARE(uuidA, QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c5")); - QCOMPARE(uuidA, QUuid("fc69b59e-cc34-4436-a43c-ee95d128b8c5")); - QCOMPARE(QUuid(), QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c")); - QCOMPARE(QUuid(), QUuid("{fc69b59e-cc34")); - QCOMPARE(QUuid(), QUuid("fc69b59e-cc34-")); - QCOMPARE(QUuid(), QUuid("fc69b59e-cc34")); - QCOMPARE(QUuid(), QUuid("cc34")); - QCOMPARE(QUuid(), QUuid(NULL)); + QTestPrivate::testAllComparisonOperatorsCompile<QUuid>(); +#if defined(Q_OS_WIN) + QTestPrivate::testEqualityOperatorsCompile<QUuid, GUID>(); +#endif +} - QCOMPARE(uuidB, QUuid(QString("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}"))); +void tst_QUuid::fromChar() +{ + QT_TEST_EQUALITY_OPS(uuidA, QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}"), true); + QT_TEST_EQUALITY_OPS(uuidA, QUuid("fc69b59e-cc34-4436-a43c-ee95d128b8c5}"), true); + QT_TEST_EQUALITY_OPS(uuidA, QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c5"), true); + QT_TEST_EQUALITY_OPS(uuidA, QUuid("fc69b59e-cc34-4436-a43c-ee95d128b8c5"), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c"), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid("{fc69b59e-cc34"), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid("fc69b59e-cc34-"), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid("fc69b59e-cc34"), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid("cc34"), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid(nullptr), true); + + QT_TEST_EQUALITY_OPS(uuidB, QUuid(QString("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}")), true); } void tst_QUuid::toString() @@ -135,7 +150,7 @@ void tst_QUuid::fromString_data() ROW(uuidA, "{fc69b59e-cc34-4436-a43c-ee95d128b8c56"); // too long (not an error!) ROW(invalid, "{fc69b59e-cc34-4436-a43c-ee95d128b8c" ); // premature end (within length limits) ROW(invalid, " fc69b59e-cc34-4436-a43c-ee95d128b8c5}"); // leading space - ROW(uuidA, "{fc69b59e-cc34-4436-a43c-ee95d128b8c5 "); // trailing space (not an error!) + ROW(uuidB, "{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b "); // trailing space (not an error!) ROW(invalid, "{gc69b59e-cc34-4436-a43c-ee95d128b8c5}"); // non-hex digit in 1st group ROW(invalid, "{fc69b59e-cp34-4436-a43c-ee95d128b8c5}"); // non-hex digit in 2nd group ROW(invalid, "{fc69b59e-cc34-44r6-a43c-ee95d128b8c5}"); // non-hex digit in 3rd group @@ -160,21 +175,21 @@ void tst_QUuid::fromString() const auto inputL1 = input.toLatin1(); const auto inputU8 = input.toUtf8(); - QCOMPARE(expected, QUuid(input)); - QCOMPARE(expected, QUuid(inputU8)); - QCOMPARE(expected, QUuid(inputL1)); + QT_TEST_EQUALITY_OPS(expected, QUuid(input), true); + QT_TEST_EQUALITY_OPS(expected, QUuid(inputU8), true); + QT_TEST_EQUALITY_OPS(expected, QUuid(inputL1), true); - QCOMPARE(expected, QUuid::fromString(input)); + QT_TEST_EQUALITY_OPS(expected, QUuid::fromString(input), true); // for QLatin1String, construct one whose data() is not NUL-terminated: const auto longerInputL1 = inputL1 + '5'; // the '5' makes the premature end check incorrectly succeed const auto inputL1S = QLatin1String(longerInputL1.data(), inputL1.size()); - QCOMPARE(expected, QUuid::fromString(inputL1S)); + QT_TEST_EQUALITY_OPS(expected, QUuid::fromString(inputL1S), true); // for QUtf8StringView, too: const auto longerInputU8 = inputU8 + '5'; // the '5' makes the premature end check incorrectly succeed const auto inputU8S = QUtf8StringView(longerInputU8.data(), inputU8.size()); - QCOMPARE(expected, QUuid::fromString(inputU8S)); + QT_TEST_EQUALITY_OPS(expected, QUuid::fromString(inputU8S), true); } void tst_QUuid::toByteArray() @@ -194,37 +209,112 @@ void tst_QUuid::toByteArray() void tst_QUuid::fromByteArray() { - QCOMPARE(uuidA, QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}"))); - QCOMPARE(uuidA, QUuid(QByteArray("fc69b59e-cc34-4436-a43c-ee95d128b8c5}"))); - QCOMPARE(uuidA, QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5"))); - QCOMPARE(uuidA, QUuid(QByteArray("fc69b59e-cc34-4436-a43c-ee95d128b8c5"))); - QCOMPARE(QUuid(), QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c"))); + QT_TEST_EQUALITY_OPS(uuidA, QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}")), true); + QT_TEST_EQUALITY_OPS(uuidA, QUuid(QByteArray("fc69b59e-cc34-4436-a43c-ee95d128b8c5}")), true); + QT_TEST_EQUALITY_OPS(uuidA, QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5")), true); + QT_TEST_EQUALITY_OPS(uuidA, QUuid(QByteArray("fc69b59e-cc34-4436-a43c-ee95d128b8c5")), true); + QT_TEST_EQUALITY_OPS(QUuid(), QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c")), true); - QCOMPARE(uuidB, QUuid(QByteArray("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}"))); + QT_TEST_EQUALITY_OPS(uuidB, QUuid(QByteArray("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}")), true); } void tst_QUuid::toRfc4122() { QCOMPARE(uuidA.toRfc4122(), QByteArray::fromHex("fc69b59ecc344436a43cee95d128b8c5")); - QCOMPARE(uuidB.toRfc4122(), QByteArray::fromHex("1ab6e93ab1cb4a87ba47ec7e99039a7b")); } void tst_QUuid::fromRfc4122() { - QCOMPARE(uuidA, QUuid::fromRfc4122(QByteArray::fromHex("fc69b59ecc344436a43cee95d128b8c5"))); + QT_TEST_EQUALITY_OPS( + uuidA, + QUuid::fromRfc4122(QByteArray::fromHex("fc69b59ecc344436a43cee95d128b8c5")), true); - QCOMPARE(uuidB, QUuid::fromRfc4122(QByteArray::fromHex("1ab6e93ab1cb4a87ba47ec7e99039a7b"))); + QT_TEST_EQUALITY_OPS( + uuidB, QUuid::fromRfc4122(QByteArray::fromHex("1ab6e93ab1cb4a87ba47ec7e99039a7b")), + true); +} + +void tst_QUuid::id128() +{ + constexpr QUuid::Id128Bytes bytesA = { { + 0xfc, 0x69, 0xb5, 0x9e, + 0xcc, 0x34, + 0x44, 0x36, + 0xa4, 0x3c, 0xee, 0x95, 0xd1, 0x28, 0xb8, 0xc5, + } }; + constexpr QUuid::Id128Bytes bytesB = { { + 0x1a, 0xb6, 0xe9, 0x3a, + 0xb1, 0xcb, + 0x4a, 0x87, + 0xba, 0x47, 0xec, 0x7e, 0x99, 0x03, 0x9a, 0x7b, + } }; + + QT_TEST_EQUALITY_OPS(QUuid(bytesA), uuidA, true); + QT_TEST_EQUALITY_OPS(QUuid(bytesB), uuidB, true); + QVERIFY(memcmp(uuidA.toBytes().data, bytesA.data, sizeof(QUuid::Id128Bytes)) == 0); + QVERIFY(memcmp(uuidB.toBytes().data, bytesB.data, sizeof(QUuid::Id128Bytes)) == 0); + + QUuid::Id128Bytes leBytesA = {}; + for (int i = 0; i < 16; i++) + leBytesA.data[15 - i] = bytesA.data[i]; + QT_TEST_EQUALITY_OPS(QUuid(leBytesA, QSysInfo::LittleEndian), uuidA, true); + QVERIFY(memcmp(uuidA.toBytes(QSysInfo::LittleEndian).data, leBytesA.data, sizeof(leBytesA)) == 0); + + // check the new q{To,From}{Big,Little}Endian() overloads + QUuid::Id128Bytes roundtrip = qFromLittleEndian(qToLittleEndian(bytesA)); + QVERIFY(memcmp(roundtrip.data, bytesA.data, sizeof(bytesA)) == 0); + roundtrip = qFromBigEndian(qToBigEndian(bytesA)); + QVERIFY(memcmp(roundtrip.data, bytesA.data, sizeof(bytesA)) == 0); +#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN + const QUuid::Id128Bytes beBytesA = qToBigEndian(leBytesA); + QVERIFY(memcmp(beBytesA.data, bytesA.data, sizeof(beBytesA)) == 0); + const QUuid::Id128Bytes otherLeBytesA = qFromBigEndian(bytesA); + QVERIFY(memcmp(otherLeBytesA.data, leBytesA.data, sizeof(leBytesA)) == 0); +#else // Q_BIG_ENDIAN + const QUuid::Id128Bytes otherLeBytesA = qToLittleEndian(bytesA); + QVERIFY(memcmp(otherLeBytesA.data, leBytesA.data, sizeof(leBytesA)) == 0); + const QUuid::Id128Bytes beBytesA = qFromLittleEndian(leBytesA); + QVERIFY(memcmp(beBytesA.data, bytesA.data, sizeof(beBytesA)) == 0); +#endif // Q_BYTE_ORDER == Q_LITTLE_ENDIAN +} + +void tst_QUuid::uint128() +{ +#ifdef QT_SUPPORTS_INT128 + constexpr quint128 u = Q_UINT128_C(0xfc69b59e'cc344436'a43cee95'd128b8c5); // This is LE + constexpr quint128 be = qToBigEndian(u); + constexpr QUuid uuid = QUuid::fromUInt128(be); + static_assert(uuid.toUInt128() == be, "Round-trip through QUuid failed"); + + QT_TEST_EQUALITY_OPS(uuid, uuidA, true); + QCOMPARE(uuid.toUInt128(), be); + + quint128 le = qFromBigEndian(be); + QCOMPARE(uuid.toUInt128(QSysInfo::LittleEndian), le); + QT_TEST_EQUALITY_OPS(QUuid::fromUInt128(le, QSysInfo::LittleEndian), uuidA, true); + + QUuid::Id128Bytes bytes = { .data128 = { qToBigEndian(u) } }; + QUuid uuid2(bytes); + QT_TEST_EQUALITY_OPS(uuid2, uuid, true); + + // verify that toBytes() and toUInt128() provide bytewise similar result + constexpr quint128 val = uuid.toUInt128(); + bytes = uuid.toBytes(); + QVERIFY(memcmp(&val, bytes.data, sizeof(val)) == 0); +#else + QSKIP("This platform has no support for 128-bit integer"); +#endif } void tst_QUuid::createUuidV3OrV5() { //"www.widgets.com" is also from RFC4122 - QCOMPARE(uuidC, QUuid::createUuidV3(uuidNS, QByteArray("www.widgets.com"))); - QCOMPARE(uuidC, QUuid::createUuidV3(uuidNS, QString("www.widgets.com"))); + QT_TEST_EQUALITY_OPS(uuidC, QUuid::createUuidV3(uuidNS, QByteArray("www.widgets.com")), true); + QT_TEST_EQUALITY_OPS(uuidC, QUuid::createUuidV3(uuidNS, QString("www.widgets.com")), true); - QCOMPARE(uuidD, QUuid::createUuidV5(uuidNS, QByteArray("www.widgets.com"))); - QCOMPARE(uuidD, QUuid::createUuidV5(uuidNS, QString("www.widgets.com"))); + QT_TEST_EQUALITY_OPS(uuidD, QUuid::createUuidV5(uuidNS, QByteArray("www.widgets.com")), true); + QT_TEST_EQUALITY_OPS(uuidD, QUuid::createUuidV5(uuidNS, QString("www.widgets.com")), true); } void tst_QUuid::check_QDataStream() @@ -240,7 +330,7 @@ void tst_QUuid::check_QDataStream() QDataStream in(&ar,QIODevice::ReadOnly); in.setByteOrder(QDataStream::BigEndian); in >> tmp; - QCOMPARE(uuidA, tmp); + QT_TEST_EQUALITY_OPS(uuidA, tmp, true); } { QDataStream out(&ar,QIODevice::WriteOnly); @@ -251,7 +341,7 @@ void tst_QUuid::check_QDataStream() QDataStream in(&ar,QIODevice::ReadOnly); in.setByteOrder(QDataStream::LittleEndian); in >> tmp; - QCOMPARE(uuidA, tmp); + QT_TEST_EQUALITY_OPS(uuidA, tmp, true); } } @@ -266,14 +356,14 @@ void tst_QUuid::isNull() void tst_QUuid::equal() { - QVERIFY( !(uuidA == uuidB) ); + QT_TEST_EQUALITY_OPS(uuidA, uuidB, false); QUuid copy(uuidA); - QCOMPARE(uuidA, copy); + QT_TEST_EQUALITY_OPS(uuidA, copy, true); QUuid assigned; assigned = uuidA; - QCOMPARE(uuidA, assigned); + QT_TEST_EQUALITY_OPS(uuidA, assigned, true); } @@ -294,6 +384,123 @@ void tst_QUuid::cpp11() { #endif } +constexpr QUuid make_minimal(QUuid::Variant variant) +{ + using V = QUuid::Variant; + switch (variant) { + case V::VarUnknown: // special case + return {}; + case V::NCS: // special case: null would be NCS, but is treated as Unknown + return {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + case V::DCE: // special case: DCE should be 0b100, but is 0b10 + return {0, 0, 0, 0b1000'0000, 0, 0, 0, 0, 0, 0, 0}; + case V::Microsoft: + case V::Reserved: + return {0, 0, 0, uchar(variant << 5), 0, 0, 0, 0, 0, 0, 0}; + } +} + +void tst_QUuid::ordering_data() +{ + QTest::addColumn<QUuid>("lhs"); + QTest::addColumn<QUuid>("rhs"); + QTest::addColumn<Qt::strong_ordering>("expected"); + + // QUuid is sorted by variant() first, then the dataN fields, in order + // Exhaustive testing is pointless, so pick some strategic values + + constexpr QUuid null = make_minimal(QUuid::Variant::VarUnknown); + QCOMPARE(null.variant(), QUuid::Variant::VarUnknown); + + constexpr QUuid minNCS = make_minimal(QUuid::Variant::NCS); + QCOMPARE(minNCS.variant(), QUuid::Variant::NCS); + + constexpr QUuid ncs000_0000_0001 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + QCOMPARE(ncs000_0000_0001, minNCS); + constexpr QUuid ncs000_0000_0010 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0}; + constexpr QUuid ncs000_0000_0100 = {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}; + constexpr QUuid ncs000_0000_1000 = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0}; + + constexpr QUuid ncs000_0001_0000 = {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}; + constexpr QUuid ncs000_0010_0000 = {0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}; + constexpr QUuid ncs000_0100_0000 = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}; + constexpr QUuid ncs000_1000_0000 = {0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}; + + constexpr QUuid ncs001_0000_0000 = {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0}; + constexpr QUuid ncs010_0000_0000 = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + constexpr QUuid ncs100_0000_0000 = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + constexpr QUuid minDCE = make_minimal(QUuid::Variant::DCE); + QCOMPARE(minDCE.variant(), QUuid::Variant::DCE); + + constexpr QUuid minMS = make_minimal(QUuid::Variant::Microsoft); + QCOMPARE(minMS.variant(), QUuid::Variant::Microsoft); + + constexpr QUuid minR = make_minimal(QUuid::Variant::Reserved); + QCOMPARE(minR.variant(), QUuid::Variant::Reserved); + + constexpr QUuid ones = {0xFFFF'FFFFU, 0xFFFFu, 0xFFFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu, 0xFFu}; + QCOMPARE(ones.variant(), QUuid::Variant::Reserved); + +#define ROW(l, r, c) \ + QTest::addRow("%s<>%s", #l, #r) << l << r << Qt::strong_ordering:: c \ + /* end */ +#define EQUAL(x) ROW(x, x, equal) + EQUAL(null); + EQUAL(minNCS); + EQUAL(minDCE); + EQUAL(minMS); + EQUAL(minR); + EQUAL(ones); +#undef EQUAL +#define AFTER_NULL(x) ROW(null, x, less) + AFTER_NULL(minNCS); + AFTER_NULL(minDCE); + AFTER_NULL(minMS); + AFTER_NULL(minR); + AFTER_NULL(ones); +#undef AFTER_NULL +#define AFTER_NCS(x) ROW(minNCS, x, less) + AFTER_NCS(ncs000_0000_0010); + AFTER_NCS(ncs000_0000_0100); + AFTER_NCS(ncs000_0000_1000); + AFTER_NCS(ncs000_0001_0000); + AFTER_NCS(ncs000_0010_0000); + AFTER_NCS(ncs000_0100_0000); + AFTER_NCS(ncs000_1000_0000); + AFTER_NCS(ncs001_0000_0000); + AFTER_NCS(ncs010_0000_0000); + AFTER_NCS(ncs100_0000_0000); + ROW(ncs100_0000_0000, minDCE, less); + AFTER_NCS(minDCE); + AFTER_NCS(minMS); + AFTER_NCS(minR); + AFTER_NCS(ones); +#undef AFTER_NCS +#define AFTER_DCE(x) ROW(minDCE, x, less) + AFTER_DCE(minMS); + AFTER_DCE(minR); + AFTER_DCE(ones); +#undef AFTER_DCE +#define AFTER_MS(x) ROW(minMS, x, less) + AFTER_MS(minR); + AFTER_MS(ones); +#undef AFTER_MS +#define AFTER_R(x) ROW(minR, x, less) + AFTER_R(ones); +#undef AFTER_R +#undef ROW +} + +void tst_QUuid::ordering() +{ + QFETCH(const QUuid, lhs); + QFETCH(const QUuid, rhs); + QFETCH(const Qt::strong_ordering, expected); + + QT_TEST_ALL_COMPARISON_OPS(lhs, rhs, expected); +} + void tst_QUuid::generate() { QUuid shouldnt_be_null_uuidA = QUuid::createUuid(); @@ -310,10 +517,12 @@ void tst_QUuid::less() QVERIFY( uuidB <= uuidA); QVERIFY(!(uuidA < uuidB) ); QVERIFY(!(uuidA <= uuidB)); + QT_TEST_ALL_COMPARISON_OPS(uuidB, uuidA, Qt::strong_ordering::less); QUuid null_uuid; QVERIFY(null_uuid < uuidA); // Null uuid is always less than a valid one QVERIFY(null_uuid <= uuidA); + QT_TEST_ALL_COMPARISON_OPS(null_uuid, uuidA, Qt::strong_ordering::less); QVERIFY(null_uuid <= null_uuid); QVERIFY(uuidA <= uuidA); @@ -326,6 +535,7 @@ void tst_QUuid::more() QVERIFY( uuidA >= uuidB); QVERIFY(!(uuidB > uuidA)); QVERIFY(!(uuidB >= uuidA)); + QT_TEST_ALL_COMPARISON_OPS(uuidA, uuidB, Qt::strong_ordering::greater); QUuid null_uuid; QVERIFY(!(null_uuid > uuidA)); // Null uuid is always less than a valid one @@ -333,6 +543,7 @@ void tst_QUuid::more() QVERIFY(null_uuid >= null_uuid); QVERIFY(uuidA >= uuidA); + QT_TEST_ALL_COMPARISON_OPS(uuidA, uuidA, Qt::strong_ordering::equal); } @@ -372,13 +583,13 @@ public: void tst_QUuid::threadUniqueness() { QList<UuidThread *> threads(qMax(2, QThread::idealThreadCount())); - for (int i = 0; i < threads.count(); ++i) + for (int i = 0; i < threads.size(); ++i) threads[i] = new UuidThread; - for (int i = 0; i < threads.count(); ++i) + for (int i = 0; i < threads.size(); ++i) threads[i]->start(); - for (int i = 0; i < threads.count(); ++i) + for (int i = 0; i < threads.size(); ++i) QVERIFY(threads[i]->wait(1000)); - for (int i = 1; i < threads.count(); ++i) + for (int i = 1; i < threads.size(); ++i) QVERIFY(threads[0]->uuid != threads[i]->uuid); qDeleteAll(threads); } @@ -396,7 +607,7 @@ void tst_QUuid::processUniqueness() QString processTwoOutput; // Start it once -#ifdef Q_OS_MAC +#ifdef Q_OS_DARWIN process.start("testProcessUniqueness/testProcessUniqueness.app"); #elif defined(Q_OS_ANDROID) process.start("libtestProcessUniqueness.so"); @@ -407,7 +618,7 @@ void tst_QUuid::processUniqueness() processOneOutput = process.readAllStandardOutput(); // Start it twice -#ifdef Q_OS_MAC +#ifdef Q_OS_DARWIN process.start("testProcessUniqueness/testProcessUniqueness.app"); #elif defined(Q_OS_ANDROID) process.start("libtestProcessUniqueness.so"); @@ -438,7 +649,7 @@ void tst_QUuid::qvariant() QUuid uuid2 = v.value<QUuid>(); QVERIFY(!uuid2.isNull()); - QCOMPARE(uuid, uuid2); + QT_TEST_EQUALITY_OPS(uuid, uuid2, true); } void tst_QUuid::qvariant_conversion() @@ -470,7 +681,7 @@ void tst_QUuid::qvariant_conversion() QVariant sv = QVariant::fromValue(uuid.toByteArray()); QCOMPARE(sv.metaType(), QMetaType(QMetaType::QByteArray)); QVERIFY(sv.canConvert<QUuid>()); - QCOMPARE(sv.value<QUuid>(), uuid); + QT_TEST_EQUALITY_OPS(sv.value<QUuid>(), uuid, true); } } diff --git a/tests/auto/corelib/plugin/quuid/tst_quuid_darwin.mm b/tests/auto/corelib/plugin/quuid/tst_quuid_darwin.mm index b8d4f034cf..c3fc809b1f 100644 --- a/tests/auto/corelib/plugin/quuid/tst_quuid_darwin.mm +++ b/tests/auto/corelib/plugin/quuid/tst_quuid_darwin.mm @@ -1,5 +1,5 @@ // Copyright (C) 2016 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QtCore/QUuid> #include <QTest> |