diff options
Diffstat (limited to 'tests/auto/corelib')
106 files changed, 1917 insertions, 503 deletions
diff --git a/tests/auto/corelib/animation/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/corelib/animation/qpropertyanimation/tst_qpropertyanimation.cpp index 03755fa7ab..3ebec35f12 100644 --- a/tests/auto/corelib/animation/qpropertyanimation/tst_qpropertyanimation.cpp +++ b/tests/auto/corelib/animation/qpropertyanimation/tst_qpropertyanimation.cpp @@ -7,6 +7,7 @@ #include <QAnimationGroup> #include <QSequentialAnimationGroup> #include <QtCore/qpropertyanimation.h> +#include <QtCore/qtimer.h> #include <QtCore/qvariantanimation.h> #include <private/qabstractanimation_p.h> #include <QtGui/qpointingdevice.h> diff --git a/tests/auto/corelib/global/CMakeLists.txt b/tests/auto/corelib/global/CMakeLists.txt index 7970116672..2b26c494d0 100644 --- a/tests/auto/corelib/global/CMakeLists.txt +++ b/tests/auto/corelib/global/CMakeLists.txt @@ -4,7 +4,9 @@ if(NOT INTEGRITY) add_subdirectory(qcompare) endif() +if(NOT WASM) # QTBUG-121822 add_subdirectory(qcomparehelpers) +endif() add_subdirectory(qflags) add_subdirectory(q_func_info) add_subdirectory(qgetputenv) @@ -16,6 +18,9 @@ if(NOT INTEGRITY) add_subdirectory(qnativeinterface) endif() add_subdirectory(qrandomgenerator) +if (QT_FEATURE_settings) + add_subdirectory(qlibraryinfo) +endif() add_subdirectory(qlogging) add_subdirectory(qtendian) add_subdirectory(qglobalstatic) diff --git a/tests/auto/corelib/global/q20/CMakeLists.txt b/tests/auto/corelib/global/q20/CMakeLists.txt index bd28f8b999..141f94d9f7 100644 --- a/tests/auto/corelib/global/q20/CMakeLists.txt +++ b/tests/auto/corelib/global/q20/CMakeLists.txt @@ -1 +1,3 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause add_subdirectory(memory) diff --git a/tests/auto/corelib/global/qcompare/tst_qcompare.cpp b/tests/auto/corelib/global/qcompare/tst_qcompare.cpp index e36429e62b..556c8212b3 100644 --- a/tests/auto/corelib/global/qcompare/tst_qcompare.cpp +++ b/tests/auto/corelib/global/qcompare/tst_qcompare.cpp @@ -785,9 +785,10 @@ void tst_QCompare::compareThreeWay() static_assert(noexcept(qCompareThreeWay(std::declval<TestEnum>(), std::declval<TestEnum>()))); // pointers - static_assert(noexcept(qCompareThreeWay(std::declval<StringWrapper *>(), - std::declval<StringWrapper *>()))); - static_assert(noexcept(qCompareThreeWay(std::declval<StringWrapper *>(), nullptr))); + using StringWrapperPtr = Qt::totally_ordered_wrapper<StringWrapper *>; + static_assert(noexcept(qCompareThreeWay(std::declval<StringWrapperPtr>(), + std::declval<StringWrapperPtr>()))); + static_assert(noexcept(qCompareThreeWay(std::declval<StringWrapperPtr>(), nullptr))); // Test some actual comparison results @@ -832,8 +833,17 @@ void tst_QCompare::compareThreeWay() // pointers std::array<int, 2> arr{1, 0}; +#if QT_DEPRECATED_SINCE(6, 8) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED QCOMPARE_EQ(qCompareThreeWay(&arr[1], &arr[0]), Qt::strong_ordering::greater); QCOMPARE_EQ(qCompareThreeWay(arr.data(), &arr[0]), Qt::strong_ordering::equivalent); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 8) + const auto a0 = Qt::totally_ordered_wrapper(&arr[0]); + const auto a1 = Qt::totally_ordered_wrapper(&arr[1]); + QCOMPARE_EQ(qCompareThreeWay(a1, a0), Qt::strong_ordering::greater); + QCOMPARE_EQ(qCompareThreeWay(arr.data(), a0), Qt::strong_ordering::equivalent); } QTEST_MAIN(tst_QCompare) diff --git a/tests/auto/corelib/global/qcomparehelpers/CMakeLists.txt b/tests/auto/corelib/global/qcomparehelpers/CMakeLists.txt index 31d8bff0a5..6b584dc7ca 100644 --- a/tests/auto/corelib/global/qcomparehelpers/CMakeLists.txt +++ b/tests/auto/corelib/global/qcomparehelpers/CMakeLists.txt @@ -11,6 +11,10 @@ qt_internal_add_test(tst_qcomparehelpers SOURCES tst_qcomparehelpers.h tst_qcomparehelpers.cpp tst_qcomparehelpers1.cpp wrappertypes.h + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::TestPrivate ) @@ -22,7 +26,10 @@ if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20" AND NOT MACOS AND NOT VXWORKS AND SOURCES tst_qcomparehelpers.h tst_qcomparehelpers.cpp tst_qcomparehelpers1.cpp wrappertypes.h + NO_BATCH # QTBUG-121815 DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP tst_QCompareHelpers=tst_QCompareHelpersCpp23 LIBRARIES Qt::TestPrivate diff --git a/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.cpp b/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.cpp index f140c23ed0..a49504db8b 100644 --- a/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.cpp +++ b/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.cpp @@ -4,6 +4,8 @@ #include "tst_qcomparehelpers.h" #include "wrappertypes.h" +#include <QtCore/qscopeguard.h> + #if defined(__STDCPP_FLOAT16_T__) && __has_include(<stdfloat>) #include <stdfloat> #endif @@ -109,32 +111,12 @@ void tst_QCompareHelpers::compareStringData() void tst_QCompareHelpers::comparisonCompiles() { QTestPrivate::testAllComparisonOperatorsCompile<IntWrapper>(); - if (QTest::currentTestFailed()) - return; - QTestPrivate::testAllComparisonOperatorsCompile<IntWrapper, int>(); - if (QTest::currentTestFailed()) - return; - QTestPrivate::testAllComparisonOperatorsCompile<DoubleWrapper>(); - if (QTest::currentTestFailed()) - return; - QTestPrivate::testAllComparisonOperatorsCompile<DoubleWrapper, double>(); - if (QTest::currentTestFailed()) - return; - QTestPrivate::testAllComparisonOperatorsCompile<DoubleWrapper, IntWrapper>(); - if (QTest::currentTestFailed()) - return; - QTestPrivate::testAllComparisonOperatorsCompile<StringWrapper<QString>>(); - if (QTest::currentTestFailed()) - return; - QTestPrivate::testAllComparisonOperatorsCompile<StringWrapper<QString>, QAnyStringView>(); - if (QTest::currentTestFailed()) - return; } void tst_QCompareHelpers::compare_IntWrapper_data() @@ -498,11 +480,14 @@ enum class TestEnum : quint8 { void tst_QCompareHelpers::builtinOrder() { #define TEST_BUILTIN(Left, Right) \ - testOrderForTypes<Left, Right>(); \ - if (QTest::currentTestFailed()) { \ - qDebug("Failed Qt::compareThreeWay() test for builtin types " #Left " and " #Right); \ - return; \ - } + do { \ + auto printOnFailure = qScopeGuard([] { \ + qDebug("Failed Qt::compareThreeWay() test for builtin types %s and %s", \ + #Left, #Right); \ + }); \ + testOrderForTypes<Left, Right>(); \ + printOnFailure.dismiss(); \ + } while (false); // some combinations TEST_BUILTIN(char, char) @@ -581,20 +566,46 @@ void tst_QCompareHelpers::builtinOrder() Qt::strong_ordering::equivalent); std::array<int, 2> arr{1, 0}; +#if QT_DEPRECATED_SINCE(6, 8) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED QCOMPARE_EQ(Qt::compareThreeWay(&arr[0], &arr[1]), Qt::strong_ordering::less); QCOMPARE_EQ(Qt::compareThreeWay(arr.data(), &arr[0]), Qt::strong_ordering::equivalent); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 8) class Base {}; class Derived : public Base {}; auto b = std::make_unique<Base>(); auto d = std::make_unique<Derived>(); +#if QT_DEPRECATED_SINCE(6, 8) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED QCOMPARE_NE(Qt::compareThreeWay(b.get(), d.get()), Qt::strong_ordering::equivalent); QCOMPARE_EQ(Qt::compareThreeWay(b.get(), nullptr), Qt::strong_ordering::greater); QCOMPARE_EQ(Qt::compareThreeWay(nullptr, d.get()), Qt::strong_ordering::less); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 8) + + // Check Qt::totally_ordered_wrapper + auto a0 = Qt::totally_ordered_wrapper(&arr[0]); + auto a1 = Qt::totally_ordered_wrapper(&arr[1]); + QCOMPARE_EQ(Qt::compareThreeWay(a0, a1), Qt::strong_ordering::less); + QCOMPARE_EQ(Qt::compareThreeWay(arr.data(), a0), Qt::strong_ordering::equivalent); + + auto bWrapper = Qt::totally_ordered_wrapper(b.get()); + auto dWrapper = Qt::totally_ordered_wrapper(d.get()); + QCOMPARE_NE(Qt::compareThreeWay(bWrapper, dWrapper), Qt::strong_ordering::equivalent); + QCOMPARE_NE(Qt::compareThreeWay(bWrapper, d.get()), Qt::strong_ordering::equivalent); + QCOMPARE_NE(Qt::compareThreeWay(b.get(), dWrapper), Qt::strong_ordering::equivalent); + QCOMPARE_EQ(Qt::compareThreeWay(bWrapper, nullptr), Qt::strong_ordering::greater); + QCOMPARE_EQ(Qt::compareThreeWay(nullptr, dWrapper), Qt::strong_ordering::less); + dWrapper.reset(nullptr); + QCOMPARE_EQ(Qt::compareThreeWay(nullptr, dWrapper), Qt::strong_ordering::equivalent); #undef TEST_BUILTIN } QTEST_MAIN(tst_QCompareHelpers) -#include "tst_qcomparehelpers.moc" +#include "moc_tst_qcomparehelpers.cpp" diff --git a/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.h b/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.h index 16398b0978..89d8a26947 100644 --- a/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.h +++ b/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers.h @@ -9,6 +9,10 @@ #include <QtTest/qtest.h> #include <QtTest/private/qcomparisontesthelper_p.h> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + class tst_QCompareHelpers : public QObject { Q_OBJECT @@ -58,6 +62,8 @@ private Q_SLOTS: // Add new test cases to tst_qcomparehelpers1.cpp, because minGW already // complains about a too large tst_qcomparehelpers.cpp.obj object file void compareWithAttributes(); + + void totallyOrderedWrapperBasics(); }; #endif // TST_QCOMPAREHELPERS_H diff --git a/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers1.cpp b/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers1.cpp index a3b8200a63..33967f314c 100644 --- a/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers1.cpp +++ b/tests/auto/corelib/global/qcomparehelpers/tst_qcomparehelpers1.cpp @@ -4,23 +4,26 @@ #include "tst_qcomparehelpers.h" #define DECLARE_TYPE(Name, Type, RetType, Constexpr, Suffix) \ -class Deprecated ## Name \ +class Templated ## Name \ { \ public: \ - Constexpr Deprecated ## Name () {} \ + Constexpr Templated ## Name () {} \ \ private: \ + template <typename X> \ friend Constexpr bool \ - comparesEqual(const Deprecated ## Name &lhs, int rhs) noexcept; \ + comparesEqual(const Templated ## Name &lhs, X rhs) noexcept; \ + template <typename X> \ friend Constexpr RetType \ - compareThreeWay(const Deprecated ## Name &lhs, int rhs) noexcept; \ - Q_DECLARE_ ## Type ## _ORDERED ## Suffix (Deprecated ## Name, int, \ - Q_DECL_DEPRECATED_X("This op is deprecated")) \ + compareThreeWay(const Templated ## Name &lhs, X rhs) noexcept; \ + Q_DECLARE_ ## Type ## _ORDERED ## Suffix (Templated ## Name, X, template <typename X>) \ }; \ \ -Constexpr bool comparesEqual(const Deprecated ## Name &lhs, int rhs) noexcept \ +template <typename X> \ +Constexpr bool comparesEqual(const Templated ## Name &lhs, X rhs) noexcept \ { Q_UNUSED(lhs); Q_UNUSED(rhs); return true; } \ -Constexpr RetType compareThreeWay(const Deprecated ## Name &lhs, int rhs) noexcept \ +template <typename X> \ +Constexpr RetType compareThreeWay(const Templated ## Name &lhs, X rhs) noexcept \ { Q_UNUSED(lhs); Q_UNUSED(rhs); return RetType::equivalent; } DECLARE_TYPE(PartialConst, PARTIALLY, Qt::partial_ordering, constexpr, _LITERAL_TYPE) @@ -34,10 +37,6 @@ DECLARE_TYPE(Strong, STRONGLY, Qt::strong_ordering, , ) void tst_QCompareHelpers::compareWithAttributes() { - // All these comparisons would trigger deprecation warnings. -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - #define COMPARE(ClassName) \ do { \ ClassName c; \ @@ -46,14 +45,19 @@ QT_WARNING_DISABLE_DEPRECATED QCOMPARE_GE(0, c); \ } while (false) - COMPARE(DeprecatedPartialConst); - COMPARE(DeprecatedPartial); - COMPARE(DeprecatedWeakConst); - COMPARE(DeprecatedWeak); - COMPARE(DeprecatedStrongConst); - COMPARE(DeprecatedStrong); + COMPARE(TemplatedPartialConst); + COMPARE(TemplatedPartial); + COMPARE(TemplatedWeakConst); + COMPARE(TemplatedWeak); + COMPARE(TemplatedStrongConst); + COMPARE(TemplatedStrong); #undef COMPARE +} -QT_WARNING_POP +void tst_QCompareHelpers::totallyOrderedWrapperBasics() +{ + Qt::totally_ordered_wrapper<int*> pi; // partially-formed + pi = nullptr; + QCOMPARE_EQ(pi.get(), nullptr); } diff --git a/tests/auto/corelib/global/qfloat16/tst_qfloat16.cpp b/tests/auto/corelib/global/qfloat16/tst_qfloat16.cpp index 7acf8c2cf6..5f1ff67316 100644 --- a/tests/auto/corelib/global/qfloat16/tst_qfloat16.cpp +++ b/tests/auto/corelib/global/qfloat16/tst_qfloat16.cpp @@ -155,6 +155,7 @@ void tst_qfloat16::ordering_data() row(2.0f, -inf); row(-2.0f, nan); row(-inf, -2.0f); + // testing with values outside qfloat16 range row(0.0f, 13e5f); // generateRow(inf, 13e5f); // fails qfloat16 vs qfloat16 and qfloat16 vs int (QTBUG-118193) @@ -187,11 +188,21 @@ void tst_qfloat16::ordering() #undef CHECK_FP + auto check_int = [=](auto rhs) { + // check that we're in range before converting, otherwise + // [conv.fpint]/1 says it would be UB + using RHS = decltype(rhs); + if (right > double(std::numeric_limits<RHS>::max())) + return; + if (auto min = std::numeric_limits<RHS>::min(); min != 0 && right < double(min)) + return; + rhs = RHS(right); + const auto expectedRes = Qt::compareThreeWay(left, rhs); + QTestPrivate::testAllComparisonOperators(lhs, rhs, expectedRes); + }; #define CHECK_INT(RHS) \ do { \ - const auto rhs = static_cast<RHS>(right); \ - const auto expectedRes = Qt::compareThreeWay(left, rhs); \ - QTestPrivate::testAllComparisonOperators(lhs, rhs, expectedRes); \ + check_int(static_cast<RHS>(0)); \ POSTCHECK("qfloat16 vs " #RHS " comparison failed") \ } while (false) \ /* END */ diff --git a/tests/auto/corelib/global/qglobal/tst_qglobal.cpp b/tests/auto/corelib/global/qglobal/tst_qglobal.cpp index 1a19048bbe..3fc91e4f59 100644 --- a/tests/auto/corelib/global/qglobal/tst_qglobal.cpp +++ b/tests/auto/corelib/global/qglobal/tst_qglobal.cpp @@ -261,7 +261,7 @@ void tst_QGlobal::qtry() void tst_QGlobal::checkptr() { - int i; + int i = 0; QCOMPARE(q_check_ptr(&i), &i); const char *c = "hello"; diff --git a/tests/auto/corelib/global/qlibraryinfo/CMakeLists.txt b/tests/auto/corelib/global/qlibraryinfo/CMakeLists.txt new file mode 100644 index 0000000000..d72e871967 --- /dev/null +++ b/tests/auto/corelib/global/qlibraryinfo/CMakeLists.txt @@ -0,0 +1,24 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qlibraryinfo LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + + +qt_internal_add_test(tst_qlibraryinfo SOURCES tst_qlibraryinfo.cpp + LIBRARIES + Qt::CorePrivate + +) + +qt_add_resources(tst_qlibraryinfo "qtconffiles" + PREFIX "/" + FILES + empty.qt.conf + partial.qt.conf + list.qt.conf + merge.qt.conf +) diff --git a/tests/auto/corelib/global/qlibraryinfo/empty.qt.conf b/tests/auto/corelib/global/qlibraryinfo/empty.qt.conf new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/auto/corelib/global/qlibraryinfo/empty.qt.conf diff --git a/tests/auto/corelib/global/qlibraryinfo/list.qt.conf b/tests/auto/corelib/global/qlibraryinfo/list.qt.conf new file mode 100644 index 0000000000..9271b414ca --- /dev/null +++ b/tests/auto/corelib/global/qlibraryinfo/list.qt.conf @@ -0,0 +1,2 @@ +[Paths] +Documentation = "/path/to/mydoc","/path/to/anotherdoc","relativePath" diff --git a/tests/auto/corelib/global/qlibraryinfo/merge.qt.conf b/tests/auto/corelib/global/qlibraryinfo/merge.qt.conf new file mode 100644 index 0000000000..a687dc4d71 --- /dev/null +++ b/tests/auto/corelib/global/qlibraryinfo/merge.qt.conf @@ -0,0 +1,5 @@ +[Paths] +QmlImports = "/path/to/myqml" + +[Config] +MergeQtConf=true diff --git a/tests/auto/corelib/global/qlibraryinfo/partial.qt.conf b/tests/auto/corelib/global/qlibraryinfo/partial.qt.conf new file mode 100644 index 0000000000..bba214c2a6 --- /dev/null +++ b/tests/auto/corelib/global/qlibraryinfo/partial.qt.conf @@ -0,0 +1,2 @@ +[Paths] +QmlImports = "/path/to/myqml" diff --git a/tests/auto/corelib/global/qlibraryinfo/tst_qlibraryinfo.cpp b/tests/auto/corelib/global/qlibraryinfo/tst_qlibraryinfo.cpp new file mode 100644 index 0000000000..b7d79c05f5 --- /dev/null +++ b/tests/auto/corelib/global/qlibraryinfo/tst_qlibraryinfo.cpp @@ -0,0 +1,103 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QTest> +#include <QtCore/qlibraryinfo.h> +#include <QtCore/qscopeguard.h> +#include <QtCore/private/qlibraryinfo_p.h> + + +class tst_QLibraryInfo : public QObject +{ + Q_OBJECT +private slots: + void initTestCase(); + void cleanup(); + void path_data(); + void path(); + void paths(); + void merge(); +}; + +void tst_QLibraryInfo::initTestCase() +{ +#if !QT_CONFIG(settings) + QSKIP("QSettings support is required for the test to run."); +#endif +} + +void tst_QLibraryInfo::cleanup() +{ + QLibraryInfoPrivate::setQtconfManualPath(nullptr); + QLibraryInfoPrivate::reload(); +} + +void tst_QLibraryInfo::path_data() +{ + QTest::addColumn<QString>("qtConfPath"); + QTest::addColumn<QLibraryInfo::LibraryPath>("path"); + QTest::addColumn<QString>("expected"); + + // TODO: deal with bundle on macOs? + QString baseDir = QCoreApplication::applicationDirPath(); + + // empty means we fall-back to default entries + QTest::addRow("empty_qmlimports") << ":/empty.qt.conf" << QLibraryInfo::QmlImportsPath << (baseDir + "/qml"); + QTest::addRow("empty_Data") << ":/empty.qt.conf" << QLibraryInfo::DataPath << baseDir; + + // partial override; use given entry if provided, otherwise default + QTest::addRow("partial_qmlimports") << ":/partial.qt.conf" << QLibraryInfo::QmlImportsPath << "/path/to/myqml"; + QTest::addRow("partial_Data") << ":/partial.qt.conf" << QLibraryInfo::DataPath << baseDir; +} + +void tst_QLibraryInfo::path() +{ + QFETCH(QString, qtConfPath); + QFETCH(QLibraryInfo::LibraryPath, path); + QFETCH(QString, expected); + + QLibraryInfoPrivate::setQtconfManualPath(&qtConfPath); + QLibraryInfoPrivate::reload(); + QString value = QLibraryInfo::path(path); + QCOMPARE(value, expected); + + // check consistency with paths + auto values = QLibraryInfo::paths(path); + QVERIFY(!values.isEmpty()); + QCOMPARE(values.first(), expected); +} + +void tst_QLibraryInfo::paths() +{ + QString qtConfPath(u":/list.qt.conf"); + QLibraryInfoPrivate::setQtconfManualPath(&qtConfPath); + QLibraryInfoPrivate::reload(); + + QList<QString> values = QLibraryInfo::paths(QLibraryInfo::DocumentationPath); + QCOMPARE(values.length(), 3); + QCOMPARE(values[0], "/path/to/mydoc"); + QCOMPARE(values[1], "/path/to/anotherdoc"); + QString baseDir = QCoreApplication::applicationDirPath(); + QCOMPARE(values[2], baseDir + "/relativePath"); +} + +void tst_QLibraryInfo::merge() +{ + QString qtConfPath(u":/merge.qt.conf"); + QLibraryInfoPrivate::setQtconfManualPath(&qtConfPath); + QLibraryInfoPrivate::reload(); + + QString baseDir = QCoreApplication::applicationDirPath(); + QString docPath = QLibraryInfo::path(QLibraryInfo::DocumentationPath); + // we can't know where exactly the doc path points, but it should not point to ${baseDir}/doc, + // which would be the behavior without merge_qt_conf + QCOMPARE_NE(docPath, baseDir + "/doc"); + + QList<QString> values = QLibraryInfo::paths(QLibraryInfo::QmlImportsPath); + QCOMPARE(values.size(), 2); // custom entry + Qt default entry + QCOMPARE(values[0], "/path/to/myqml"); +} + +QTEST_GUILESS_MAIN(tst_QLibraryInfo) + +#include "tst_qlibraryinfo.moc" diff --git a/tests/auto/corelib/global/qxp/CMakeLists.txt b/tests/auto/corelib/global/qxp/CMakeLists.txt index 2178f446db..8292462d17 100644 --- a/tests/auto/corelib/global/qxp/CMakeLists.txt +++ b/tests/auto/corelib/global/qxp/CMakeLists.txt @@ -1,2 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause add_subdirectory(function_ref) add_subdirectory(is_virtual_base_of) diff --git a/tests/auto/corelib/io/CMakeLists.txt b/tests/auto/corelib/io/CMakeLists.txt index 7fdf4b52b0..ccd0bf2959 100644 --- a/tests/auto/corelib/io/CMakeLists.txt +++ b/tests/auto/corelib/io/CMakeLists.txt @@ -25,7 +25,7 @@ add_subdirectory(qloggingcategory) add_subdirectory(qnodebug) add_subdirectory(qsavefile) add_subdirectory(qstandardpaths) -if(NOT QNX) +if(NOT QNX AND NOT VXWORKS) add_subdirectory(qstorageinfo) endif() add_subdirectory(qtemporarydir) @@ -63,8 +63,16 @@ if(QT_FEATURE_processenvironment) add_subdirectory(qprocessenvironment) endif() if(QT_FEATURE_settings AND TARGET Qt::Gui) + if(NOT WASM) # QTBUG-121822 add_subdirectory(qsettings) + endif() endif() if(QT_FEATURE_private_tests) add_subdirectory(qzip) endif() +if(NOT (MACOS AND "$ENV{QT_BUILD_ENVIRONMENT}" STREQUAL "ci")) + # On macOS the new features require at least macOS 13.3, + # but we also run the tests on older OS versions. + # So just skip macOS on CI for now. + add_subdirectory(qfloat16format) +endif() diff --git a/tests/auto/corelib/io/largefile/tst_largefile.cpp b/tests/auto/corelib/io/largefile/tst_largefile.cpp index 6fa3569c4f..f5af3bde63 100644 --- a/tests/auto/corelib/io/largefile/tst_largefile.cpp +++ b/tests/auto/corelib/io/largefile/tst_largefile.cpp @@ -46,6 +46,10 @@ public: // This means that files are limited to 2 GB − 1 bytes. // Limit max size to 256MB maxSizeBits = 28; // 256 MiB + #elif defined(Q_OS_VXWORKS) + // VxWorks doesn't support sparse files, also, default /tmp directory is a RAM-disk which + // limits its capacity. + maxSizeBits = 28; // 256 MiB #elif defined (Q_OS_WASM) maxSizeBits = 28; // 256 MiB #elif defined(QT_LARGEFILE_SUPPORT) @@ -494,6 +498,7 @@ void tst_LargeFile::mapFile() // 32-bit: limited to 44-bit offsets (when sizeof(off_t) == 8) //Windows: memory-mapping beyond EOF is not allowed //wasm: as for linux +//VxWorks: memory-mapping beyond EOF is not allowed void tst_LargeFile::mapOffsetOverflow() { enum { @@ -506,6 +511,9 @@ void tst_LargeFile::mapOffsetOverflow() #elif (defined(Q_OS_LINUX) || defined(Q_OS_ANDROID)) && (Q_PROCESSOR_WORDSIZE == 4) Succeeds = true, MaxOffset = sizeof(QT_OFF_T) > 4 ? 43 : 30 +#elif defined(Q_OS_VXWORKS) + Succeeds = false, + MaxOffset = 8 * sizeof(QT_OFF_T) - 1 #else Succeeds = true, MaxOffset = 8 * sizeof(QT_OFF_T) - 1 diff --git a/tests/auto/corelib/io/qdir/tst_qdir.cpp b/tests/auto/corelib/io/qdir/tst_qdir.cpp index b19f158746..7b05a88e81 100644 --- a/tests/auto/corelib/io/qdir/tst_qdir.cpp +++ b/tests/auto/corelib/io/qdir/tst_qdir.cpp @@ -438,7 +438,7 @@ void tst_QDir::mkdirOnSymlink() // create our structure: dir.mkpath("two/three"); - ::symlink("two/three", "symlink"); + QCOMPARE(::symlink("two/three", "symlink"), 0); // try it: QString path = "symlink/../four/five"; @@ -2285,6 +2285,8 @@ void tst_QDir::equalityOperator_data() QString pathinroot("/system/.."); #elif defined(Q_OS_HAIKU) QString pathinroot("/boot/.."); +#elif defined(Q_OS_VXWORKS) + QString pathinroot("/tmp/.."); #else QString pathinroot("/usr/.."); #endif diff --git a/tests/auto/corelib/io/qdirlisting/tst_qdirlisting.cpp b/tests/auto/corelib/io/qdirlisting/tst_qdirlisting.cpp index bb4e1b30d2..e2ac1858da 100644 --- a/tests/auto/corelib/io/qdirlisting/tst_qdirlisting.cpp +++ b/tests/auto/corelib/io/qdirlisting/tst_qdirlisting.cpp @@ -85,9 +85,12 @@ private slots: void uncPaths(); #endif #ifndef Q_OS_WIN - void hiddenDirs_hiddenFiles(); + void hiddenFiles(); + void hiddenDirs(); #endif + void withStdAlgorithms(); + private: QSharedPointer<QTemporaryDir> m_dataDir; }; @@ -173,10 +176,10 @@ void tst_QDirListing::initTestCase() createFile("hiddenDirs_hiddenFiles/normalDirectory/.hiddenFile"); createFile("hiddenDirs_hiddenFiles/.hiddenDirectory/normalFile"); createFile("hiddenDirs_hiddenFiles/.hiddenDirectory/.hiddenFile"); - createDirectory("hiddenDirs_hiddenFiles/normalDirectory/normalDirectory"); - createDirectory("hiddenDirs_hiddenFiles/normalDirectory/.hiddenDirectory"); - createDirectory("hiddenDirs_hiddenFiles/.hiddenDirectory/normalDirectory"); - createDirectory("hiddenDirs_hiddenFiles/.hiddenDirectory/.hiddenDirectory"); + createDirectory("hiddenDirs_hiddenFiles/normalDirectory/subdir"); + createDirectory("hiddenDirs_hiddenFiles/normalDirectory/.hidden-subdir"); + createDirectory("hiddenDirs_hiddenFiles/.hiddenDirectory/subdir"); + createDirectory("hiddenDirs_hiddenFiles/.hiddenDirectory/.hidden-subdir"); #endif } @@ -571,40 +574,77 @@ void tst_QDirListing::uncPaths() // In Unix it is easy to create hidden files, but in Windows it requires // a special call since hidden files need to be "marked" while in Unix // anything starting by a '.' is a hidden file. -// For that reason this test is not run in Windows. -void tst_QDirListing::hiddenDirs_hiddenFiles() +// For that reason these two tests aren't run on Windows. + +void tst_QDirListing::hiddenFiles() { - // Only files - { - int matches = 0; - int failures = 0; - constexpr auto filters = QDir::Files | QDir::Hidden | QDir::NoDotAndDotDot; - for (const auto &dirEntry : QDirListing(u"hiddenDirs_hiddenFiles"_s, filters, - ItFlag::Recursive)) { - ++matches; - if (dirEntry.isDir()) - ++failures; // search was only supposed to find files - } - QCOMPARE(matches, 6); - QCOMPARE(failures, 0); + QStringList expected = { + "hiddenDirs_hiddenFiles/normalFile"_L1, + "hiddenDirs_hiddenFiles/.hiddenFile"_L1, + "hiddenDirs_hiddenFiles/normalDirectory/normalFile"_L1, + "hiddenDirs_hiddenFiles/normalDirectory/.hiddenFile"_L1, + "hiddenDirs_hiddenFiles/.hiddenDirectory/normalFile"_L1, + "hiddenDirs_hiddenFiles/.hiddenDirectory/.hiddenFile"_L1, + }; + expected.sort(); + + constexpr auto filters = QDir::Files | QDir::Hidden | QDir::NoDotAndDotDot; + QStringList list; + list.reserve(expected.size()); + for (const auto &dirEntry : QDirListing(u"hiddenDirs_hiddenFiles"_s, filters, + ItFlag::Recursive)) { + QVERIFY(dirEntry.isFile()); + list.emplace_back(dirEntry.filePath()); } - // Only directories - { - int matches = 0; - int failures = 0; - constexpr auto filters = QDir::Dirs | QDir::Hidden | QDir::NoDotAndDotDot; - for (const auto &dirEntry : QDirListing(u"hiddenDirs_hiddenFiles"_s, filters, - ItFlag::Recursive)) { - ++matches; - if (!dirEntry.isDir()) - ++failures; // search was only supposed to find files - } - QCOMPARE(matches, 6); - QCOMPARE(failures, 0); + + list.sort(); + + QCOMPARE_EQ(list, expected); +} + +void tst_QDirListing::hiddenDirs() +{ + QStringList expected = { + "hiddenDirs_hiddenFiles/normalDirectory"_L1, + "hiddenDirs_hiddenFiles/normalDirectory/subdir"_L1, + "hiddenDirs_hiddenFiles/normalDirectory/.hidden-subdir"_L1, + "hiddenDirs_hiddenFiles/.hiddenDirectory"_L1, + "hiddenDirs_hiddenFiles/.hiddenDirectory/subdir"_L1, + "hiddenDirs_hiddenFiles/.hiddenDirectory/.hidden-subdir"_L1, + }; + expected.sort(); + + constexpr auto filters = QDir::Dirs | QDir::Hidden | QDir::NoDotAndDotDot; + QStringList list; + list.reserve(expected.size()); + for (const auto &dirEntry : QDirListing(u"hiddenDirs_hiddenFiles"_s, filters, + ItFlag::Recursive)) { + QVERIFY(dirEntry.isDir()); + list.emplace_back(dirEntry.filePath()); } + list.sort(); + + QCOMPARE_EQ(list, expected); } + #endif // Q_OS_WIN +void tst_QDirListing::withStdAlgorithms() +{ + QDirListing dirList(u"entrylist"_s, QDir::AllEntries | QDir::NoDotAndDotDot, ItFlag::Recursive); + + std::for_each(dirList.cbegin(), dirList.cend(), [](const auto &dirEntry) { + QVERIFY(dirEntry.absoluteFilePath().contains("entrylist")); + }); + + const auto fileName = "dummy"_L1; + auto it = std::find_if(dirList.cbegin(), dirList.cend(), [fileName](const auto &dirEntry) { + return dirEntry.fileName() == fileName; + }); + QVERIFY(it != dirList.cend()); + QCOMPARE(it->fileName(), fileName); +} + QTEST_MAIN(tst_QDirListing) #include "tst_qdirlisting.moc" diff --git a/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp b/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp index f7d531f61f..563e4c2a83 100644 --- a/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp +++ b/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp @@ -1217,9 +1217,16 @@ void tst_QFileInfo::setFileTimes() QCOMPARE(file.write(data), data.size()); QCOMPARE(file.size(), data.size()); - const QDateTime before = QDateTime::currentDateTimeUtc().addMSecs(-5000); + QDateTime before = QDateTime::currentDateTimeUtc().addMSecs(-5000); + QVERIFY(file.setFileTime(before, QFile::FileModificationTime)); const QDateTime mtime = file.fileTime(QFile::FileModificationTime).toUTC(); + if (mtime.time().msec() == 0) + { + const QTime beforeTime = before.time(); + const QTime beforeTimeWithMSCutOff{beforeTime.hour(), beforeTime.minute(), beforeTime.second(), 0}; + before.setTime(beforeTimeWithMSCutOff); + } QCOMPARE(mtime, before); } diff --git a/tests/auto/corelib/io/qfileselector/CMakeLists.txt b/tests/auto/corelib/io/qfileselector/CMakeLists.txt index c27c4f4f96..aafdddb595 100644 --- a/tests/auto/corelib/io/qfileselector/CMakeLists.txt +++ b/tests/auto/corelib/io/qfileselector/CMakeLists.txt @@ -47,8 +47,11 @@ set(qfileselector_resource_files "platforms/+unix/+haiku/test" "platforms/+unix/+linux/test" "platforms/+unix/+qnx/test" + "platforms/+unix/+vxworks/test" "platforms/+unix/test" "platforms/+unix/test3" + "platforms/+vxworks/test" + "platforms/+vxworks/test2" "platforms/+wince/test" "platforms/+wince/test2" "platforms/+windows/+wince/test" diff --git a/tests/auto/corelib/io/qfileselector/platforms/+unix/+vxworks/test b/tests/auto/corelib/io/qfileselector/platforms/+unix/+vxworks/test new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/auto/corelib/io/qfileselector/platforms/+unix/+vxworks/test diff --git a/tests/auto/corelib/io/qfileselector/platforms/+vxworks/test b/tests/auto/corelib/io/qfileselector/platforms/+vxworks/test new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/auto/corelib/io/qfileselector/platforms/+vxworks/test diff --git a/tests/auto/corelib/io/qfileselector/platforms/+vxworks/test2 b/tests/auto/corelib/io/qfileselector/platforms/+vxworks/test2 new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/auto/corelib/io/qfileselector/platforms/+vxworks/test2 diff --git a/tests/auto/corelib/io/qfileselector/tst_qfileselector.cpp b/tests/auto/corelib/io/qfileselector/tst_qfileselector.cpp index 626166c8b8..82c9d5ef37 100644 --- a/tests/auto/corelib/io/qfileselector/tst_qfileselector.cpp +++ b/tests/auto/corelib/io/qfileselector/tst_qfileselector.cpp @@ -61,7 +61,7 @@ void tst_QFileSelector::basicTest_data() QString expectedPlatform2File(""); //Only the last selector QString expectedPlatform3File; // Only the first selector (the family) #if defined(Q_OS_UNIX) && !defined(Q_OS_ANDROID) && !defined(Q_OS_WASM) && \ - !defined(Q_OS_DARWIN) && !defined(Q_OS_LINUX) && !defined(Q_OS_HAIKU) && !defined(Q_OS_QNX) + !defined(Q_OS_DARWIN) && !defined(Q_OS_LINUX) && !defined(Q_OS_HAIKU) && !defined(Q_OS_QNX) && !defined(Q_OS_VXWORKS) /* We are only aware of specific unixes, and do not have test files for any of the others. However those unixes can get a selector added from the result of a uname call, so this will lead to a case where we don't have that file so we can't expect the concatenation of platform diff --git a/tests/auto/corelib/io/qfilesystemwatcher/tst_qfilesystemwatcher.cpp b/tests/auto/corelib/io/qfilesystemwatcher/tst_qfilesystemwatcher.cpp index a5b0087f9c..184eef3f15 100644 --- a/tests/auto/corelib/io/qfilesystemwatcher/tst_qfilesystemwatcher.cpp +++ b/tests/auto/corelib/io/qfilesystemwatcher/tst_qfilesystemwatcher.cpp @@ -26,14 +26,18 @@ using namespace std::chrono_literals; #if defined(Q_OS_QNX) -// Longer polling times on QNX, otherwise the tests fail on the CI +constexpr bool isQNX = true; +#else +constexpr bool isQNX = false; +#endif + +#if defined(Q_OS_QNX) || defined(Q_OS_VXWORKS) +// Longer polling times on QNX and VxWorks, otherwise the tests fail on the CI constexpr auto nativeEngineTimeout = 1s; constexpr auto pollingEngineTimeout = 1s; -constexpr bool isQNX = true; #else constexpr auto nativeEngineTimeout = 0ms; constexpr auto pollingEngineTimeout = 20ms; -constexpr bool isQNX = false; #endif /* All tests need to run in temporary directories not used diff --git a/tests/auto/corelib/io/qfloat16format/CMakeLists.txt b/tests/auto/corelib/io/qfloat16format/CMakeLists.txt new file mode 100644 index 0000000000..88c47d8de3 --- /dev/null +++ b/tests/auto/corelib/io/qfloat16format/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qfloat16format LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +set(CMAKE_OSX_DEPLOYMENT_TARGET 13.3) + +qt_internal_add_test(tst_qfloat16format + SOURCES + tst_qfloat16format.cpp +) + +if(NOT VXWORKS) + set_target_properties(tst_qfloat16format + PROPERTIES + CXX_STANDARD 20 + CXX_STANDARD_REQUIRED OFF + ) +endif() diff --git a/tests/auto/corelib/io/qfloat16format/tst_qfloat16format.cpp b/tests/auto/corelib/io/qfloat16format/tst_qfloat16format.cpp new file mode 100644 index 0000000000..ea07b327af --- /dev/null +++ b/tests/auto/corelib/io/qfloat16format/tst_qfloat16format.cpp @@ -0,0 +1,157 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QTest> + +#include <QtCore/qcompilerdetection.h> +#include <QtCore/qdebug.h> +#include <QtCore/qfloat16format.h> +#include <QtCore/qstring.h> + +using namespace Qt::StringLiterals; + +class tst_QFloat16Format : public QObject +{ + Q_OBJECT + +private slots: + void initTestCase(); + void formatCompileTime(); + void format_data(); + void format(); + void formatMultiArg(); +}; + +void tst_QFloat16Format::initTestCase() +{ +#ifndef QT_SUPPORTS_STD_FORMAT + QSKIP("This test requires std::format support!"); +#endif +} + +void tst_QFloat16Format::formatCompileTime() +{ +#ifdef QT_SUPPORTS_STD_FORMAT + // Starting from __cpp_lib_format == 202106L, + // std::format requires the format string to be evaluated at compile-time, + // so check it here. + + const qfloat16 val{1.234f}; + std::locale loc{"C"}; + + // char + std::string buffer; + std::format_to(std::back_inserter(buffer), "{}", val); + std::format_to(std::back_inserter(buffer), "{:*>15.7f}", val); + std::format_to(std::back_inserter(buffer), "{:*^+#15.7g}", val); + std::format_to(std::back_inserter(buffer), "{:*<-#15.7A}", val); + std::format_to(std::back_inserter(buffer), "{:*^ 15.7e}", val); + std::format_to(std::back_inserter(buffer), loc, "{:*^10.3Lf}", val); + std::format_to(std::back_inserter(buffer), loc, "{:*< 10.7LE}", val); + + // wchar_t + std::wstring wbuffer; + std::format_to(std::back_inserter(wbuffer), L"{}", val); + std::format_to(std::back_inserter(wbuffer), L"{:*>15.7f}", val); + std::format_to(std::back_inserter(wbuffer), L"{:*^+#15.7g}", val); + std::format_to(std::back_inserter(wbuffer), L"{:*<-#15.7A}", val); + std::format_to(std::back_inserter(wbuffer), L"{:*^ 15.7e}", val); + std::format_to(std::back_inserter(wbuffer), loc, L"{:*^10.3Lf}", val); + std::format_to(std::back_inserter(wbuffer), loc, L"{:*< 10.7LE}", val); +#endif // QT_SUPPORTS_STD_FORMAT +} + +void tst_QFloat16Format::format_data() +{ +#ifdef QT_SUPPORTS_STD_FORMAT + QTest::addColumn<QString>("format"); + QTest::addColumn<qfloat16>("value"); + QTest::addColumn<std::locale>("locale"); + QTest::addColumn<QString>("expectedString"); + + auto row = [](const QString &format, qfloat16 val, const QString &expected, + const std::locale &loc = std::locale::classic()) + { + QTest::addRow("%s:%s", loc.name().c_str(), qPrintable(format)) + << format << val << loc << expected; + }; + + row(u"{}"_s, qfloat16(1.f), u"1"_s); + row(u"{:#}"_s, qfloat16(1.f), u"1."_s); + row(u"{:f}"_s, qfloat16(1.f), u"1.000000"_s); + row(u"{:*>10.2a}"_s, qfloat16(-1.23f), u"**-1.3bp+0"_s); + + try { + // check if this locale is a) valid and b) works as expected +#if defined(Q_CC_MSVC) + std::locale loc("de-DE"); +#else + std::locale loc("de_DE"); +#endif + if (std::format(loc, "{:L}", 1.25) == "1,25") { + row(u"{:+Lf}"_s, qfloat16(1.f), u"+1,000000"_s, loc); + row(u"{:*^10.3LF}"_s, qfloat16(-0.1234f), u"**-0,123**"_s, loc); + row(u"{:*^#10.4Lg}"_s, qfloat16(-1.f), u"**-1,000**"_s, loc); + row(u"{:*<14.3LE}"_s, qfloat16(-0.1234f), u"-1,234E-01****"_s, loc); + } + } catch (const std::runtime_error &) { + // locale doesn't exist (std::locale constructor threw) + } +#endif // QT_SUPPORTS_STD_FORMAT +} + +void tst_QFloat16Format::format() +{ +#ifdef QT_SUPPORTS_STD_FORMAT + QFETCH(const QString, format); + QFETCH(const qfloat16, value); + QFETCH(const std::locale, locale); + QFETCH(const QString, expectedString); + + // char + { + std::string buffer; + const auto formatStr = format.toStdString(); + std::vformat_to(std::back_inserter(buffer), locale, formatStr, + std::make_format_args(value)); + const QString actualString = QString::fromStdString(buffer); + QCOMPARE_EQ(actualString, expectedString); + } + + // wchar_t + { + std::wstring buffer; + const auto formatStr = format.toStdWString(); + std::vformat_to(std::back_inserter(buffer), locale, formatStr, + std::make_wformat_args(value)); + const QString actualString = QString::fromStdWString(buffer); + QCOMPARE_EQ(actualString, expectedString); + } +#endif // QT_SUPPORTS_STD_FORMAT +} + +void tst_QFloat16Format::formatMultiArg() +{ +#ifdef QT_SUPPORTS_STD_FORMAT + const qfloat16 v1{-0.1234f}; + const qfloat16 v2{5.67f}; + + const QString expectedString = u"**+5.67**_*****-1.234E-01"_s; + // char + { + std::string buffer; + std::format_to(std::back_inserter(buffer), "{1:*^+9.2f}_{0:*>15.3E}", v1, v2); + QCOMPARE_EQ(QString::fromStdString(buffer), expectedString); + } + + // wchar_t + { + std::wstring buffer; + std::format_to(std::back_inserter(buffer), L"{1:*^+9.2f}_{0:*>15.3E}", v1, v2); + QCOMPARE_EQ(QString::fromStdWString(buffer), expectedString); + } +#endif // QT_SUPPORTS_STD_FORMAT +} + +QTEST_MAIN(tst_QFloat16Format) +#include "tst_qfloat16format.moc" diff --git a/tests/auto/corelib/io/qprocess/crasher.h b/tests/auto/corelib/io/qprocess/crasher.h index 7d55bf980f..f1ca82a86b 100644 --- a/tests/auto/corelib/io/qprocess/crasher.h +++ b/tests/auto/corelib/io/qprocess/crasher.h @@ -45,6 +45,8 @@ void crash() { #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)) __ud2(); +#elif defined(_MSC_VER) && defined(_M_ARM64) + __debugbreak(); #elif __has_builtin(__builtin_trap) __builtin_trap(); #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) diff --git a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp index 5f35732979..316c388bc8 100644 --- a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp +++ b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp @@ -1715,7 +1715,7 @@ void tst_QProcess::raiseInChildProcessModifier() sa.sa_flags = SA_RESETHAND; sa.sa_handler = [](int) { static const char msg[] = "SIGUSR1 handler was run"; - write(STDERR_FILENO, msg, strlen(msg)); + (void)write(STDERR_FILENO, msg, strlen(msg)); raise(SIGUSR1); // re-raise }; sigaction(SIGUSR1, &sa, nullptr); @@ -1897,8 +1897,8 @@ void tst_QProcess::unixProcessParametersAndChildModifier() process.setChildProcessModifier([=, &vforkControl] { const char *pgidmsg = "PGID mismatch. "; if (getpgrp() != oldpgid) - write(pipes[1], pgidmsg, strlen(pgidmsg)); - write(pipes[1], message, strlen(message)); + (void)write(pipes[1], pgidmsg, strlen(pgidmsg)); + (void)write(pipes[1], message, strlen(message)); vforkControl.storeRelaxed(1); }); auto flags = QProcess::UnixProcessFlag::CloseFileDescriptors | diff --git a/tests/auto/corelib/io/qprocessenvironment/tst_qprocessenvironment.cpp b/tests/auto/corelib/io/qprocessenvironment/tst_qprocessenvironment.cpp index 6a2a3daaa2..560d4196b2 100644 --- a/tests/auto/corelib/io/qprocessenvironment/tst_qprocessenvironment.cpp +++ b/tests/auto/corelib/io/qprocessenvironment/tst_qprocessenvironment.cpp @@ -257,6 +257,9 @@ void tst_QProcessEnvironment::caseSensitivity() void tst_QProcessEnvironment::systemEnvironment() { +#ifdef Q_OS_VXWORKS + QSKIP("VxWorks do not have PATH environment variable"); +#endif static const char envname[] = "THIS_ENVIRONMENT_VARIABLE_HOPEFULLY_DOESNT_EXIST"; QByteArray path = qgetenv("PATH"); QByteArray nonexistant = qgetenv(envname); diff --git a/tests/auto/corelib/io/qresourceengine/generateResources.sh b/tests/auto/corelib/io/qresourceengine/generateResources.sh index 18d1e0b80f..ab05f1c35a 100755 --- a/tests/auto/corelib/io/qresourceengine/generateResources.sh +++ b/tests/auto/corelib/io/qresourceengine/generateResources.sh @@ -1,6 +1,6 @@ +#!/bin/sh # Copyright (C) 2016 Intel Corporation. # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 -#!/bin/sh count=`awk '/ZERO_FILE_LEN/ { print $3 }' tst_qresourceengine.cpp` dd if=/dev/zero of=zero.txt bs=1 count=$count rcc --binary -o uncompressed.rcc --no-compress compressed.qrc diff --git a/tests/auto/corelib/io/qresourceengine/staticplugin/main.cpp b/tests/auto/corelib/io/qresourceengine/staticplugin/main.cpp index 39a3a1e012..c7b0fe7ea1 100644 --- a/tests/auto/corelib/io/qresourceengine/staticplugin/main.cpp +++ b/tests/auto/corelib/io/qresourceengine/staticplugin/main.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QObject> class PluginClass : public QObject diff --git a/tests/auto/corelib/io/qresourceengine/tst_qresourceengine.cpp b/tests/auto/corelib/io/qresourceengine/tst_qresourceengine.cpp index f0dab35f81..00a8cc4d72 100644 --- a/tests/auto/corelib/io/qresourceengine/tst_qresourceengine.cpp +++ b/tests/auto/corelib/io/qresourceengine/tst_qresourceengine.cpp @@ -201,7 +201,6 @@ void tst_QResourceEngine::checkStructure_data() << (QStringList() #if defined(BUILTIN_TESTDATA) << "parentdir.txt" - << "runtime_resource.rcc" #endif << "search_file.txt" #if defined(BUILTIN_TESTDATA) diff --git a/tests/auto/corelib/io/qsettings/CMakeLists.txt b/tests/auto/corelib/io/qsettings/CMakeLists.txt index e68b2644af..5cad78b979 100644 --- a/tests/auto/corelib/io/qsettings/CMakeLists.txt +++ b/tests/auto/corelib/io/qsettings/CMakeLists.txt @@ -29,6 +29,10 @@ qt_internal_add_test(tst_qsettings tst_qsettings.cpp INCLUDE_DIRECTORIES ../../kernel/qmetatype + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::CorePrivate Qt::Gui diff --git a/tests/auto/corelib/io/qsettings/tst_qsettings.cpp b/tests/auto/corelib/io/qsettings/tst_qsettings.cpp index f4d7f076ef..6952f14f19 100644 --- a/tests/auto/corelib/io/qsettings/tst_qsettings.cpp +++ b/tests/auto/corelib/io/qsettings/tst_qsettings.cpp @@ -3,6 +3,10 @@ #include <QTest> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + #include <QtCore/QSettings> #include <private/qsettings_p.h> @@ -1360,7 +1364,7 @@ void tst_QSettings::testVariantTypes() QCOMPARE(settings.value("empty"), QVariant()); } - auto checker = [format](const char *key, auto value, QMetaType::Type expected) { + auto check = [format](const char *key, auto value, QMetaType::Type expected) { { QSettings settings(format, QSettings::UserScope, "software.org", "KillerAPP"); settings.setValue(key, QVariant::fromValue(value)); @@ -1373,11 +1377,6 @@ void tst_QSettings::testVariantTypes() QCOMPARE(qvariant_cast<decltype(value)>(actual), value); } }; -#define testValue(key, supplied, expected) do { \ - checker(key, supplied, QMetaType::expected); \ - if (QTest::currentTestFailed()) \ - return; \ - } while (0) typedef QMap<QString, QVariant> TestVariantMap; @@ -1385,48 +1384,46 @@ void tst_QSettings::testVariantTypes() m2.insert("ene", "due"); m2.insert("rike", "fake"); m2.insert("borba", "dorba"); - testValue("customMap", m2, QVariantMap); + check("customMap", m2, QMetaType::QVariantMap); QStringList l2 { "ene", "due", "@Point(1 2)", "@fake" }; - testValue("stringsAt", l2, QStringList); + check("stringsAt", l2, QMetaType::QStringList); l2 = { "ene", "due", "rike", "fake" }; - testValue("strings", l2, QStringList); + check("strings", l2, QMetaType::QStringList); QDate date = QDate::currentDate(); QTime time = QTime::currentTime(); QList<QVariant> l3 { QString("ene"), 10, QVariant::fromValue(QColor(1, 2, 3)), QVariant(QRect(1, 2, 3, 4)), QVariant(QSize(4, 56)), QVariant(QPoint(4, 2)), true, false, date, time }; - testValue("mixedList", l3, QVariantList); + check("mixedList", l3, QMetaType::QVariantList); - testValue("string", QString("hello"), QString); - testValue("color", QColor(1, 2, 3), QColor); - testValue("rect", QRect(1, 2, 3, 4), QRect); - testValue("size", QSize(4, 56), QSize); - testValue("point", QPoint(4, 2), QPoint); - testValue("date", date, QDate); - testValue("time", time, QTime); - testValue("byteArray", QByteArray("foo bar"), QByteArray); + check("string", QString("hello"), QMetaType::QString); + check("color", QColor(1, 2, 3), QMetaType::QColor); + check("rect", QRect(1, 2, 3, 4), QMetaType::QRect); + check("size", QSize(4, 56), QMetaType::QSize); + check("point", QPoint(4, 2), QMetaType::QPoint); + check("date", date, QMetaType::QDate); + check("time", time, QMetaType::QTime); + check("byteArray", QByteArray("foo bar"), QMetaType::QByteArray); QList<QVariant> l4 { QVariant(m2), QVariant(l2), QVariant(l3) }; - testValue("collectList", l4, QVariantList); + check("collectList", l4, QMetaType::QVariantList); QDateTime dt = QDateTime::currentDateTime(); dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(3600)); - testValue("dateTime", dt, QDateTime); + check("dateTime", dt, QMetaType::QDateTime); #if QT_CONFIG(shortcut) // We store key sequences as strings instead of binary variant blob, for improved // readability in the resulting format. QKeySequence seq(Qt::ControlModifier | Qt::Key_F1); if (format >= QSettings::InvalidFormat) - testValue("keySequence", seq, QKeySequence); + check("keySequence", seq, QMetaType::QKeySequence); else - testValue("keySequence", seq.toString(QKeySequence::NativeText), QString); + check("keySequence", seq.toString(QKeySequence::NativeText), QMetaType::QString); #endif // QT_CONFIG(shortcut) - -#undef testValue } #endif diff --git a/tests/auto/corelib/io/qstorageinfo/tst_qstorageinfo.cpp b/tests/auto/corelib/io/qstorageinfo/tst_qstorageinfo.cpp index 5242988fd1..f96cd48900 100644 --- a/tests/auto/corelib/io/qstorageinfo/tst_qstorageinfo.cpp +++ b/tests/auto/corelib/io/qstorageinfo/tst_qstorageinfo.cpp @@ -24,6 +24,8 @@ # include "../../../../../src/corelib/io/qstorageinfo_linux_p.h" #endif +using namespace Qt::StringLiterals; + class tst_QStorageInfo : public QObject { Q_OBJECT @@ -137,8 +139,10 @@ void tst_QStorageInfo::root() QVERIFY(storage.isReady()); QCOMPARE(storage.rootPath(), QDir::rootPath()); QVERIFY(storage.isRoot()); +#ifndef Q_OS_WASM QVERIFY(!storage.device().isEmpty()); QVERIFY(!storage.fileSystemType().isEmpty()); +#endif #ifndef Q_OS_HAIKU QCOMPARE_GE(storage.bytesTotal(), 0); QCOMPARE_GE(storage.bytesFree(), 0); @@ -149,6 +153,9 @@ void tst_QStorageInfo::root() void tst_QStorageInfo::currentStorage() { QString appPath = QCoreApplication::applicationFilePath(); + if (appPath.isEmpty()) + QSKIP("No applicationFilePath(), cannot test"); + QStorageInfo storage(appPath); QVERIFY(storage.isValid()); QVERIFY(storage.isReady()); @@ -308,7 +315,10 @@ void tst_QStorageInfo::freeSpaceUpdate() QCOMPARE(free, storage2.bytesFree()); storage2.refresh(); QCOMPARE(storage1, storage2); + +#ifndef Q_OS_WASM QCOMPARE_NE(free, storage2.bytesFree()); +#endif } #if defined(Q_OS_LINUX) && defined(QT_BUILD_INTERNAL) @@ -319,64 +329,64 @@ void tst_QStorageInfo::testParseMountInfo_data() QTest::newRow("tmpfs") << "17 25 0:18 / /dev rw,nosuid,relatime shared:2 - tmpfs tmpfs rw,seclabel,mode=755\n"_ba - << MountInfo{"/dev", "tmpfs", "tmpfs", "", makedev(0, 18)}; + << MountInfo{"/dev", "tmpfs", "tmpfs", "", makedev(0, 18), 17}; QTest::newRow("proc") << "23 66 0:21 / /proc rw,nosuid,nodev,noexec,relatime shared:12 - proc proc rw\n"_ba - << MountInfo{"/proc", "proc", "proc", "", makedev(0, 21)}; + << MountInfo{"/proc", "proc", "proc", "", makedev(0, 21), 23}; // E.g. on Android QTest::newRow("rootfs") << "618 618 0:1 / / ro,relatime master:1 - rootfs rootfs ro,seclabel\n"_ba - << MountInfo{"/", "rootfs", "rootfs", "", makedev(0, 1)}; + << MountInfo{"/", "rootfs", "rootfs", "", makedev(0, 1), 618}; QTest::newRow("ext4") << "47 66 8:3 / /home rw,relatime shared:50 - ext4 /dev/sda3 rw,stripe=32736\n"_ba - << MountInfo{"/home", "ext4", "/dev/sda3", "", makedev(8, 3)}; + << MountInfo{"/home", "ext4", "/dev/sda3", "", makedev(8, 3), 47}; QTest::newRow("empty-optional-field") << "23 25 0:22 / /apex rw,nosuid,nodev,noexec,relatime - tmpfs tmpfs rw,seclabel,mode=755\n"_ba - << MountInfo{"/apex", "tmpfs", "tmpfs", "", makedev(0, 22)}; + << MountInfo{"/apex", "tmpfs", "tmpfs", "", makedev(0, 22), 23}; QTest::newRow("one-optional-field") << "47 66 8:3 / /home rw,relatime shared:50 - ext4 /dev/sda3 rw,stripe=32736\n"_ba - << MountInfo{"/home", "ext4", "/dev/sda3", "", makedev(8, 3)}; + << MountInfo{"/home", "ext4", "/dev/sda3", "", makedev(8, 3), 47}; QTest::newRow("multiple-optional-fields") << "47 66 8:3 / /home rw,relatime shared:142 master:111 - ext4 /dev/sda3 rw,stripe=32736\n"_ba - << MountInfo{"/home", "ext4", "/dev/sda3", "", makedev(8, 3)}; + << MountInfo{"/home", "ext4", "/dev/sda3", "", makedev(8, 3), 47}; QTest::newRow("mountdir-with-utf8") << "129 66 8:51 / /mnt/lab\xC3\xA9l rw,relatime shared:234 - ext4 /dev/sdd3 rw\n"_ba - << MountInfo{"/mnt/labél", "ext4", "/dev/sdd3", "", makedev(8, 51)}; + << MountInfo{"/mnt/labél", "ext4", "/dev/sdd3", "", makedev(8, 51), 129}; QTest::newRow("mountdir-with-space") << "129 66 8:51 / /mnt/labe\\040l rw,relatime shared:234 - ext4 /dev/sdd3 rw\n"_ba - << MountInfo{"/mnt/labe l", "ext4", "/dev/sdd3", "", makedev(8, 51)}; + << MountInfo{"/mnt/labe l", "ext4", "/dev/sdd3", "", makedev(8, 51), 129}; QTest::newRow("mountdir-with-tab") << "129 66 8:51 / /mnt/labe\\011l rw,relatime shared:234 - ext4 /dev/sdd3 rw\n"_ba - << MountInfo{"/mnt/labe\tl", "ext4", "/dev/sdd3", "", makedev(8, 51)}; + << MountInfo{"/mnt/labe\tl", "ext4", "/dev/sdd3", "", makedev(8, 51), 129}; QTest::newRow("mountdir-with-backslash") << "129 66 8:51 / /mnt/labe\\134l rw,relatime shared:234 - ext4 /dev/sdd3 rw\n"_ba - << MountInfo{"/mnt/labe\\l", "ext4", "/dev/sdd3", "", makedev(8, 51)}; + << MountInfo{"/mnt/labe\\l", "ext4", "/dev/sdd3", "", makedev(8, 51), 129}; QTest::newRow("mountdir-with-newline") << "129 66 8:51 / /mnt/labe\\012l rw,relatime shared:234 - ext4 /dev/sdd3 rw\n"_ba - << MountInfo{"/mnt/labe\nl", "ext4", "/dev/sdd3", "", makedev(8, 51)}; + << MountInfo{"/mnt/labe\nl", "ext4", "/dev/sdd3", "", makedev(8, 51), 129}; QTest::newRow("btrfs-subvol") << "775 503 0:49 /foo/bar / rw,relatime shared:142 master:111 - btrfs " "/dev/mapper/vg0-stuff rw,ssd,discard,space_cache,subvolid=272,subvol=/foo/bar\n"_ba - << MountInfo{"/", "btrfs", "/dev/mapper/vg0-stuff", "/foo/bar", makedev(0, 49)}; + << MountInfo{"/", "btrfs", "/dev/mapper/vg0-stuff", "/foo/bar", makedev(0, 49), 775}; QTest::newRow("bind-mount") << "59 47 8:17 /rpmbuild /home/user/rpmbuild rw,relatime shared:48 - ext4 /dev/sdb1 rw\n"_ba - << MountInfo{"/home/user/rpmbuild", "ext4", "/dev/sdb1", "/rpmbuild", makedev(8, 17)}; + << MountInfo{"/home/user/rpmbuild", "ext4", "/dev/sdb1", "/rpmbuild", makedev(8, 17), 59}; QTest::newRow("space-dash-space") << "47 66 8:3 / /home\\040-\\040dir rw,relatime shared:50 - ext4 /dev/sda3 rw,stripe=32736\n"_ba - << MountInfo{"/home - dir", "ext4", "/dev/sda3", "", makedev(8, 3)}; + << MountInfo{"/home - dir", "ext4", "/dev/sda3", "", makedev(8, 3), 47}; QTest::newRow("btrfs-mount-bind-file") << "1799 1778 0:49 " @@ -385,7 +395,7 @@ void tst_QStorageInfo::testParseMountInfo_data() "rw,ssd,discard,space_cache,subvolid=1773,subvol=/var_lib_docker\n"_ba << MountInfo{"/etc/resolv.conf", "btrfs", "/dev/mapper/vg0-stuff", "/var_lib_docker/containers/81fde0fec3dd3d99765c3f7fd9cf1ab121b6ffcfd05d5d7ff434db933fe9d795/resolv.conf", - makedev(0, 49)}; + makedev(0, 49), 1799}; QTest::newRow("very-long-line-QTBUG-77059") << "727 26 0:52 / " @@ -402,13 +412,13 @@ void tst_QStorageInfo::testParseMountInfo_data() "workdir=/var/lib/docker/overlay2/f3fbad5eedef71145f00729f0826ea8c44defcfec8c92c58aee0aa2c5ea3fa3a/work," "index=off,xino=off\n"_ba << MountInfo{"/var/lib/docker/overlay2/f3fbad5eedef71145f00729f0826ea8c44defcfec8c92c58aee0aa2c5ea3fa3a/merged", - "overlay", "overlay", "", makedev(0, 52)}; + "overlay", "overlay", "", makedev(0, 52), 727}; QTest::newRow("sshfs-src-device-not-start-with-slash") << "128 92 0:64 / /mnt-point rw,nosuid,nodev,relatime shared:234 - " "fuse.sshfs admin@192.168.1.2:/storage/emulated/0 rw,user_id=1000,group_id=1000\n"_ba << MountInfo{"/mnt-point", "fuse.sshfs", - "admin@192.168.1.2:/storage/emulated/0", "", makedev(0, 64)}; + "admin@192.168.1.2:/storage/emulated/0", "", makedev(0, 64), 128}; } void tst_QStorageInfo::testParseMountInfo() @@ -424,6 +434,7 @@ void tst_QStorageInfo::testParseMountInfo() QCOMPARE(a.device, expected.device); QCOMPARE(a.fsRoot, expected.fsRoot); QCOMPARE(a.stDev, expected.stDev); + QCOMPARE(a.mntid, expected.mntid); } void tst_QStorageInfo::testParseMountInfo_filtered_data() diff --git a/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp b/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp index 579e6d5511..1419f06f86 100644 --- a/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp +++ b/tests/auto/corelib/io/qtemporaryfile/tst_qtemporaryfile.cpp @@ -592,7 +592,9 @@ void tst_QTemporaryFile::rename() void tst_QTemporaryFile::renameFdLeak() { #if defined(Q_OS_UNIX) && !defined(Q_OS_ANDROID) - const QByteArray sourceFile = QFile::encodeName(QFINDTESTDATA("CMakeLists.txt")); + QTemporaryFile file; + QVERIFY(file.open()); + const QByteArray sourceFile = QFile::encodeName(file.fileName()); QVERIFY(!sourceFile.isEmpty()); // Test this on Unix only diff --git a/tests/auto/corelib/io/qurl/tst_qurl.cpp b/tests/auto/corelib/io/qurl/tst_qurl.cpp index bd454fb695..2024968435 100644 --- a/tests/auto/corelib/io/qurl/tst_qurl.cpp +++ b/tests/auto/corelib/io/qurl/tst_qurl.cpp @@ -3776,13 +3776,13 @@ void tst_QUrl::setComponents_data() << PrettyDecoded << QString() << "foo:/path"; QTest::newRow("host-empty") << QUrl("foo://example.com/path") << int(Host) << "" << Tolerant << true - << PrettyDecoded << QString() << "foo:///path"; + << PrettyDecoded << "" << "foo:///path"; QTest::newRow("authority-null") << QUrl("foo://example.com/path") << int(Authority) << QString() << Tolerant << true << PrettyDecoded << QString() << "foo:/path"; QTest::newRow("authority-empty") << QUrl("foo://example.com/path") << int(Authority) << "" << Tolerant << true - << PrettyDecoded << QString() << "foo:///path"; + << PrettyDecoded << "" << "foo:///path"; QTest::newRow("query-null") << QUrl("http://example.com/?q=foo") << int(Query) << QString() << Tolerant << true << PrettyDecoded << QString() << "http://example.com/"; @@ -3840,10 +3840,10 @@ void tst_QUrl::setComponents_data() << PrettyDecoded << QString() << QString(); QTest::newRow("invalid-authority-1") << QUrl("http://example.com") << int(Authority) << "-not-valid-" << Tolerant << false - << PrettyDecoded << QString() << QString(); + << PrettyDecoded << "" << QString(); QTest::newRow("invalid-authority-2") << QUrl("http://example.com") << int(Authority) << "%31%30.%30.%30.%31" << Strict << false - << PrettyDecoded << QString() << QString(); + << PrettyDecoded << "" << QString(); QTest::newRow("invalid-path-0") << QUrl("http://example.com") << int(Path) << "{}" << Strict << false diff --git a/tests/auto/corelib/ipc/qsharedmemory/tst_qsharedmemory.cpp b/tests/auto/corelib/ipc/qsharedmemory/tst_qsharedmemory.cpp index 73578a3bab..5bd74da532 100644 --- a/tests/auto/corelib/ipc/qsharedmemory/tst_qsharedmemory.cpp +++ b/tests/auto/corelib/ipc/qsharedmemory/tst_qsharedmemory.cpp @@ -583,8 +583,8 @@ void tst_QSharedMemory::attachBeforeCreate() */ void tst_QSharedMemory::useTooMuchMemory() { - if (QSysInfo::productType() == QLatin1String("Debian") - || QSysInfo::productType() == QLatin1String("debian")) + if (QSysInfo::kernelType() == QLatin1String("linux") + && QSysInfo::currentCpuArchitecture() == QLatin1String("arm64")) QSKIP("This test is unstable: QTBUG-119321"); #ifdef Q_OS_LINUX diff --git a/tests/auto/corelib/itemmodels/CMakeLists.txt b/tests/auto/corelib/itemmodels/CMakeLists.txt index c0cd04df12..a8aa743887 100644 --- a/tests/auto/corelib/itemmodels/CMakeLists.txt +++ b/tests/auto/corelib/itemmodels/CMakeLists.txt @@ -5,7 +5,9 @@ add_subdirectory(qstringlistmodel) if(TARGET Qt::Gui) add_subdirectory(qabstractitemmodel) if(QT_FEATURE_proxymodel) + if (NOT WASM) # QTBUG-121822 add_subdirectory(qabstractproxymodel) + endif() add_subdirectory(qconcatenatetablesproxymodel) add_subdirectory(qidentityproxymodel) add_subdirectory(qsortfilterproxymodel_recursive) diff --git a/tests/auto/corelib/itemmodels/qabstractitemmodel/tst_qabstractitemmodel.cpp b/tests/auto/corelib/itemmodels/qabstractitemmodel/tst_qabstractitemmodel.cpp index 6b1e4ce9ba..c48b79b260 100644 --- a/tests/auto/corelib/itemmodels/qabstractitemmodel/tst_qabstractitemmodel.cpp +++ b/tests/auto/corelib/itemmodels/qabstractitemmodel/tst_qabstractitemmodel.cpp @@ -993,9 +993,9 @@ void tst_QAbstractItemModel::complexChangesWithPersistent() void tst_QAbstractItemModel::modelIndexComparisons() { - QTestPrivate::testEqualityOperatorsCompile<QModelIndex>(); - QTestPrivate::testEqualityOperatorsCompile<QPersistentModelIndex>(); - QTestPrivate::testEqualityOperatorsCompile<QPersistentModelIndex, QModelIndex>(); + QTestPrivate::testAllComparisonOperatorsCompile<QModelIndex>(); + QTestPrivate::testAllComparisonOperatorsCompile<QPersistentModelIndex>(); + QTestPrivate::testAllComparisonOperatorsCompile<QPersistentModelIndex, QModelIndex>(); QtTestModel model(3, 3); @@ -1003,13 +1003,28 @@ void tst_QAbstractItemModel::modelIndexComparisons() QModelIndex mi22 = model.index(2, 2); QPersistentModelIndex pmi11 = mi11; QPersistentModelIndex pmi22 = mi22; + QPersistentModelIndex pmiU; QT_TEST_EQUALITY_OPS(mi11, mi11, true); QT_TEST_EQUALITY_OPS(mi11, mi22, false); + QT_TEST_ALL_COMPARISON_OPS(mi11, mi11, Qt::strong_ordering::equal); + QT_TEST_ALL_COMPARISON_OPS(mi11, mi22, Qt::strong_ordering::less); + QT_TEST_ALL_COMPARISON_OPS(mi22, mi11, Qt::strong_ordering::greater); QT_TEST_EQUALITY_OPS(pmi11, pmi11, true); QT_TEST_EQUALITY_OPS(pmi11, pmi22, false); QT_TEST_EQUALITY_OPS(pmi11, mi11, true); QT_TEST_EQUALITY_OPS(pmi11, mi22, false); + + QT_TEST_ALL_COMPARISON_OPS(pmi11, pmi11, Qt::strong_ordering::equal); + QT_TEST_ALL_COMPARISON_OPS(pmi11, pmi22, Qt::strong_ordering::less); + // Disengaged QPMIs are sorted randomly (based on address of their Private) + // So all we can check here is QPMIs with d == nullptr, which should reliably + // come before any others. + QT_TEST_ALL_COMPARISON_OPS(pmiU, pmiU, Qt::strong_ordering::equal); + QT_TEST_ALL_COMPARISON_OPS(pmi11, pmiU, Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(pmi11, mi11, Qt::strong_ordering::equal); + QT_TEST_ALL_COMPARISON_OPS(pmi11, mi22, Qt::strong_ordering::less); + QT_TEST_ALL_COMPARISON_OPS(pmiU, mi11, Qt::strong_ordering::less); } void tst_QAbstractItemModel::testMoveSameParentDown_data() diff --git a/tests/auto/corelib/itemmodels/qabstractproxymodel/CMakeLists.txt b/tests/auto/corelib/itemmodels/qabstractproxymodel/CMakeLists.txt index 8799814324..ea90d1dd79 100644 --- a/tests/auto/corelib/itemmodels/qabstractproxymodel/CMakeLists.txt +++ b/tests/auto/corelib/itemmodels/qabstractproxymodel/CMakeLists.txt @@ -14,6 +14,10 @@ endif() qt_internal_add_test(tst_qabstractproxymodel SOURCES tst_qabstractproxymodel.cpp + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::Gui Qt::TestPrivate diff --git a/tests/auto/corelib/itemmodels/qabstractproxymodel/tst_qabstractproxymodel.cpp b/tests/auto/corelib/itemmodels/qabstractproxymodel/tst_qabstractproxymodel.cpp index 62512889fd..73a81f56ab 100644 --- a/tests/auto/corelib/itemmodels/qabstractproxymodel/tst_qabstractproxymodel.cpp +++ b/tests/auto/corelib/itemmodels/qabstractproxymodel/tst_qabstractproxymodel.cpp @@ -3,10 +3,17 @@ #include <QTest> #include <QtTest/private/qpropertytesthelper_p.h> + +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + #include <qabstractproxymodel.h> #include <QItemSelection> #include <qstandarditemmodel.h> +#include <QtCore/qscopeguard.h> + class tst_QAbstractProxyModel : public QObject { Q_OBJECT @@ -610,28 +617,30 @@ void tst_QAbstractProxyModel::sourceModelBinding() SubQAbstractProxyModel proxy; QStandardItemModel model1; QStandardItemModel model2; + const char *lhs; + const char *rhs; + + auto printOnFailure = qScopeGuard([&] { + qDebug("Failed %s - %s test", lhs, rhs); + }); + lhs = "model"; + rhs = "model"; QTestPrivate::testReadWritePropertyBasics<SubQAbstractProxyModel, QAbstractItemModel *>( proxy, &model1, &model2, "sourceModel"); - if (QTest::currentTestFailed()) { - qDebug("Failed model - model test"); - return; - } proxy.setSourceModel(&model2); + lhs = "model"; + rhs = "nullptr"; QTestPrivate::testReadWritePropertyBasics<SubQAbstractProxyModel, QAbstractItemModel *>( proxy, &model1, nullptr, "sourceModel"); - if (QTest::currentTestFailed()) { - qDebug("Failed model - nullptr test"); - return; - } proxy.setSourceModel(&model1); + lhs = "nullptr"; + rhs = "model"; QTestPrivate::testReadWritePropertyBasics<SubQAbstractProxyModel, QAbstractItemModel *>( proxy, nullptr, &model2, "sourceModel"); - if (QTest::currentTestFailed()) { - qDebug("Failed nullptr - model test"); - return; - } + + printOnFailure.dismiss(); } QTEST_MAIN(tst_QAbstractProxyModel) diff --git a/tests/auto/corelib/kernel/qchronotimer/tst_qchronotimer.cpp b/tests/auto/corelib/kernel/qchronotimer/tst_qchronotimer.cpp index 62c402ae24..4711853c88 100644 --- a/tests/auto/corelib/kernel/qchronotimer/tst_qchronotimer.cpp +++ b/tests/auto/corelib/kernel/qchronotimer/tst_qchronotimer.cpp @@ -20,6 +20,10 @@ #include <qelapsedtimer.h> #include <qproperty.h> +#if defined(Q_OS_WIN32) +#include <qt_windows.h> +#endif + #if defined Q_OS_UNIX #include <unistd.h> #endif @@ -57,6 +61,7 @@ private slots: void recurringTimer(); void deleteLaterOnQChronoTimer(); // long name, don't want to shadow QObject::deleteLater() void moveToThread(); + void newTimerFiresTooSoon(); void restartedTimerFiresTooSoon(); void timerFiresOnlyOncePerProcessEvents_data(); void timerFiresOnlyOncePerProcessEvents(); @@ -619,6 +624,51 @@ void tst_QChronoTimer::moveToThread() QVERIFY((ti3.id() & 0xffffff) != (timer1.id() & 0xffffff)); } +class TimerListener : public QObject +{ + Q_OBJECT +public: + void timerEvent(QTimerEvent *) override + { + m_timerElapsed = true; + } + + bool m_timerElapsed = false; +}; + +void tst_QChronoTimer::newTimerFiresTooSoon() +{ +#ifndef Q_OS_WIN32 + QSKIP("Only relevant on Windows"); +#else + // Arrange - Create timer and make sure it ticked + { + QTest::qWait(0 /*ms*/); // Clean up event queue from previous tests + + TimerListener listener; + const int timerId = listener.startTimer(50ms, Qt::CoarseTimer); + QThread::sleep(100ms); + + // Force WM_TIMER events on Windows event queue + MSG msg{}; + PeekMessage(&msg, nullptr, WM_TIMER, WM_TIMER, PM_NOREMOVE); + + listener.killTimer(timerId); + } + + // Act - Create new timer with long interval and make sure it does not immediately tick + TimerListener listener; + const int timerId = listener.startTimer(60s, Qt::CoarseTimer); + + QTest::qWait(0 /*ms*/); // Process event queue - Should not call timerEvent + listener.killTimer(timerId); + + // Assert + QEXPECT_FAIL("", "QTBUG-124496 - QObject::timerEvent may be called before the timer elapsed", Continue); + QVERIFY(!listener.m_timerElapsed); +#endif +} + class RestartedTimerFiresTooSoonObject : public QObject { Q_OBJECT diff --git a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp index 8f8ab33e64..5dc445d44f 100644 --- a/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp +++ b/tests/auto/corelib/kernel/qcoreapplication/tst_qcoreapplication.cpp @@ -1065,7 +1065,7 @@ static void createQObjectOnDestruction() // QThread) after the last QObject has been destroyed (especially after // QCoreApplication has). -#if !defined(QT_QGUIAPPLICATIONTEST) && !defined(Q_OS_WIN) +#if !defined(QT_QGUIAPPLICATIONTEST) && !defined(Q_OS_WIN) && !defined(Q_OS_VXWORKS) // QCoreApplicationData's global static destructor has run and cleaned up // the QAdoptedThread. if (theMainThreadIsSet()) diff --git a/tests/auto/corelib/kernel/qelapsedtimer/CMakeLists.txt b/tests/auto/corelib/kernel/qelapsedtimer/CMakeLists.txt index 9a40a2f905..eccde38df2 100644 --- a/tests/auto/corelib/kernel/qelapsedtimer/CMakeLists.txt +++ b/tests/auto/corelib/kernel/qelapsedtimer/CMakeLists.txt @@ -14,4 +14,6 @@ endif() qt_internal_add_test(tst_qelapsedtimer SOURCES tst_qelapsedtimer.cpp + LIBRARIES + Qt::TestPrivate ) diff --git a/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp b/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp index 7623fd2e43..7a2b12b2eb 100644 --- a/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp +++ b/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp @@ -5,6 +5,7 @@ #include <QtCore/QString> #include <QtCore/QElapsedTimer> #include <QTest> +#include <QtTest/private/qcomparisontesthelper_p.h> #include <QTimer> static const int minResolution = 100; // the minimum resolution for the tests @@ -22,6 +23,7 @@ class tst_QElapsedTimer : public QObject Q_OBJECT private Q_SLOTS: + void compareCompiles(); void statics(); void validity(); void basics(); @@ -29,6 +31,11 @@ private Q_SLOTS: void msecsTo(); }; +void tst_QElapsedTimer::compareCompiles() +{ + QTestPrivate::testAllComparisonOperatorsCompile<QElapsedTimer>(); +} + void tst_QElapsedTimer::statics() { // these have been required since Qt 6.6 @@ -77,6 +84,7 @@ void tst_QElapsedTimer::basics() QVERIFY(!(t1 < t1)); QCOMPARE(t1.msecsTo(t1), qint64(0)); QCOMPARE(t1.secsTo(t1), qint64(0)); + QT_TEST_ALL_COMPARISON_OPS(t1, t1, Qt::strong_ordering::equal); quint64 value1 = t1.msecsSinceReference(); qDebug() << "value1:" << value1 << "t1:" << t1; @@ -141,10 +149,16 @@ void tst_QElapsedTimer::msecsTo() QTest::qSleep(minResolution); QElapsedTimer t2; t2.start(); - - QVERIFY(t1 != t2); - QVERIFY(!(t1 == t2)); - QVERIFY(t1 < t2); + QTest::qSleep(minResolution); + QElapsedTimer t3; + t3.start(); + + QT_TEST_EQUALITY_OPS(t1, t2, false); + QT_TEST_EQUALITY_OPS(QElapsedTimer(), QElapsedTimer(), true); + QT_TEST_EQUALITY_OPS(QElapsedTimer(), t2, false); + QT_TEST_ALL_COMPARISON_OPS(t1, t2, Qt::strong_ordering::less); + QT_TEST_ALL_COMPARISON_OPS(t3, t2, Qt::strong_ordering::greater); + QT_TEST_ALL_COMPARISON_OPS(t3, QElapsedTimer(), Qt::strong_ordering::greater); auto diff = t1.msecsTo(t2); QVERIFY2(diff > 0, QString("difference t1 and t2 is %1").arg(diff).toLatin1()); diff --git a/tests/auto/corelib/kernel/qeventdispatcher/CMakeLists.txt b/tests/auto/corelib/kernel/qeventdispatcher/CMakeLists.txt index 1f9cfb9449..a18bdab429 100644 --- a/tests/auto/corelib/kernel/qeventdispatcher/CMakeLists.txt +++ b/tests/auto/corelib/kernel/qeventdispatcher/CMakeLists.txt @@ -19,6 +19,9 @@ endif() foreach(test ${test_names}) qt_internal_add_test(${test} NO_BATCH + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP SOURCES tst_qeventdispatcher.cpp ) diff --git a/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp b/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp index 285d080960..a61f398366 100644 --- a/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp +++ b/tests/auto/corelib/kernel/qeventdispatcher/tst_qeventdispatcher.cpp @@ -20,6 +20,10 @@ static bool glibDisabled = []() { #include <chrono> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + using namespace std::chrono_literals; static constexpr auto PreciseTimerInterval = 10ms; @@ -230,8 +234,6 @@ void tst_QEventDispatcher::registerTimer() { TimerManager timers(eventDispatcher, this); timers.registerAll(); - if (QTest::currentTestFailed()) - return; // check that all 3 are present in the eventDispatcher's registeredTimer() list QCOMPARE(timers.registeredTimers().size(), 3); @@ -267,8 +269,6 @@ void tst_QEventDispatcher::registerTimer() QCOMPARE(timerIdFromEvent, timers.preciseTimerId()); // now unregister it and make sure it's gone timers.unregister(Qt::TimerId(timers.preciseTimerId())); - if (QTest::currentTestFailed()) - return; QCOMPARE(timers.registeredTimers().size(), 2); QVERIFY(!timers.foundPrecise()); QVERIFY(timers.foundCoarse()); @@ -291,8 +291,6 @@ void tst_QEventDispatcher::registerTimer() QCOMPARE(timerIdFromEvent, timers.coarseTimerId()); // now unregister it and make sure it's gone timers.unregister(Qt::TimerId(timers.coarseTimerId())); - if (QTest::currentTestFailed()) - return; QCOMPARE(timers.registeredTimers().size(), 1); QVERIFY(!timers.foundPrecise()); QVERIFY(!timers.foundCoarse()); @@ -300,8 +298,6 @@ void tst_QEventDispatcher::registerTimer() // not going to wait for the VeryCoarseTimer, would take too long, just unregister it timers.unregisterAll(); - if (QTest::currentTestFailed()) - return; QVERIFY(timers.registeredTimers().isEmpty()); } diff --git a/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp index b7b1f95b39..2f895b7b9e 100644 --- a/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp +++ b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp @@ -17,6 +17,7 @@ public: private slots: void construct(); + void invalidArraysAreEmpty(); void size(); void operators(); }; @@ -81,6 +82,7 @@ VERIFY_RETURN_FOR_TYPE(QJniArray<List>, QJniArray<List>); void tst_QJniArray::construct() { + // explicit { QStringList strings; for (int i = 0; i < 10000; ++i) @@ -89,19 +91,66 @@ void tst_QJniArray::construct() QCOMPARE(list.size(), 10000); } { - QJniArray<jint> list{1, 2, 3}; + QJniArray bytes = QJniArrayBase::fromContainer(QByteArray("abc")); + static_assert(std::is_same_v<decltype(bytes)::value_type, jbyte>); + QCOMPARE(bytes.size(), 3); + } + { + QJniArray list{1, 2, 3}; + static_assert(std::is_same_v<decltype(list), QJniArray<int>>); QCOMPARE(list.size(), 3); + list = {4, 5}; + QCOMPARE(list.size(), 2); } { QJniArray<jint> list(QList<int>{1, 2, 3}); QCOMPARE(list.size(), 3); } + // CTAD with deduction guide + { + QJniArray list(QList<int>{1, 2, 3}); + QCOMPARE(list.size(), 3); + } + { + QJniArray bytes(QByteArray("abc")); + static_assert(std::is_same_v<decltype(bytes)::value_type, jbyte>); + QCOMPARE(bytes.size(), 3); + } + { + QStringList strings{"a", "b", "c"}; + QJniArray list(strings); + QCOMPARE(list.size(), 3); + } { QJniArray<jint> list{QList<int>{1, 2, 3}}; QCOMPARE(list.size(), 3); } } +void tst_QJniArray::invalidArraysAreEmpty() +{ + QJniArray<jchar> invalid; + QVERIFY(!invalid.isValid()); + QCOMPARE(invalid.object(), nullptr); + QVERIFY(invalid.isEmpty()); + + QCOMPARE(invalid.begin(), invalid.end()); + QCOMPARE(invalid.rbegin(), invalid.rend()); + + QList<jchar> data; + // safe to iterate + for (const auto &e : invalid) + data.emplace_back(e); + QVERIFY(data.empty()); + + // safe to convert + data = invalid.toContainer(); + QVERIFY(data.empty()); + + // unsafe to access + // auto element = invalid.at(0); +} + void tst_QJniArray::size() { QJniArray<jint> array; @@ -110,7 +159,7 @@ void tst_QJniArray::size() QList<int> intList; intList.resize(10); - auto intArray = QJniArrayBase::fromContainer(intList); + auto intArray = QJniArray(intList); QCOMPARE(intArray.size(), 10); } diff --git a/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java b/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java index 07a94d1cac..eb86a18034 100644 --- a/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java +++ b/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java @@ -43,6 +43,8 @@ public class QtJniObjectTestClass static char S_CHAR_VAR; static String S_STRING_OBJECT_VAR; + static char[] S_CHAR_ARRAY = A_STRING_OBJECT.toCharArray(); + // -------------------------------------------------------------------------------------------- public static void staticVoidMethod() { return; } public static void staticVoidMethodWithArgs(int a, boolean b, char c) { return; } @@ -199,6 +201,18 @@ public class QtJniObjectTestClass { return staticReverseCharArray(array); } // -------------------------------------------------------------------------------------------- + public static char[] getStaticCharArray() + { return S_CHAR_ARRAY; } + public static void mutateStaticCharArray(char [] values) + { + for (int i = 0; i < values.length; ++i) { + S_CHAR_ARRAY[i] = values[i]; + } + } + public static void replaceStaticCharArray(char[] array) + { S_CHAR_ARRAY = array; } + + // -------------------------------------------------------------------------------------------- public static short[] staticShortArrayMethod() { short[] array = { 3, 2, 1 }; return array; } public short[] shortArrayMethod() { return staticShortArrayMethod(); } public static short[] staticReverseShortArray(short[] array) diff --git a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp index 64b464e002..1da70b7127 100644 --- a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp +++ b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp @@ -116,6 +116,7 @@ private slots: void isClassAvailable(); void fromLocalRef(); void largeObjectArray(); + void arrayLifetime(); void callback_data(); void callback(); @@ -1627,7 +1628,7 @@ void tst_QJniObject::templateApiCheck() QCOMPARE(array.size(), 3); QCOMPARE(array.toContainer(), "abc"); - QJniArray<jbyte> newArray = QJniArrayBase::fromContainer(QByteArray{"cba"}); + QJniArray newArray = QJniArray(QByteArray{"cba"}); QVERIFY(newArray.isValid()); const auto reverse = testClass.callMethod<jbyte[]>("reverseByteArray", newArray); QVERIFY(reverse.isValid()); @@ -1884,6 +1885,42 @@ void tst_QJniObject::largeObjectArray() } } +void tst_QJniObject::arrayLifetime() +{ + const auto stringData = A_STRING_OBJECT(); + + QJniArray oldChars = TestClass::callStaticMethod<jchar[]>("getStaticCharArray"); + QVERIFY(oldChars.isValid()); + QCOMPARE(oldChars.size(), stringData.size()); + QCOMPARE(QChar(oldChars.toContainer().at(0)), stringData.at(0)); + + QJniArray<jchar> newChars{'a', 'b', 'c'}; + // replace the first three characters in the array + TestClass::callStaticMethod<void>("mutateStaticCharArray", newChars); + // the old jcharArray is still valid and the size is unchanged + QVERIFY(oldChars.isValid()); + QCOMPARE(oldChars.size(), A_STRING_OBJECT().size()); + QCOMPARE(oldChars.toContainer().at(0), jchar('a')); + + // get a second reference to the Java array + QJniArray updatedChars = TestClass::getStaticField<jchar[]>("S_CHAR_ARRAY"); + // the two QJniArrays reference the same jobject + QCOMPARE(updatedChars.size(), oldChars.size()); + QCOMPARE(updatedChars, oldChars); + + // replace the Java array; the old jcharArray is still valid and unchanged + TestClass::callStaticMethod<void>("replaceStaticCharArray", newChars); + // the old jcharArray is still valid and unchanged + QVERIFY(oldChars.isValid()); + QCOMPARE(oldChars.size(), stringData.size()); + QCOMPARE(oldChars, updatedChars); + + // we get the same object that we set + updatedChars = TestClass::getStaticField<jchar[]>("S_CHAR_ARRAY"); + QCOMPARE(updatedChars, newChars); + QCOMPARE_NE(updatedChars, oldChars); +} + enum class CallbackParameterType { Object, diff --git a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp index bf582041f3..db0700ef2f 100644 --- a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp +++ b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp @@ -63,7 +63,6 @@ Q_DECLARE_JNI_CLASS(JavaType, "org/qtproject/qt/JavaType"); static_assert(QtJniTypes::Traits<QtJniTypes::JavaType>::signature() == "Lorg/qtproject/qt/JavaType;"); static_assert(QtJniTypes::Traits<QtJniTypes::JavaType[]>::signature() == "[Lorg/qtproject/qt/JavaType;"); -Q_DECLARE_JNI_CLASS(String, "java/lang/String"); static_assert(QtJniTypes::Traits<jstring>::className() == "java/lang/String"); static_assert(QtJniTypes::Traits<QtJniTypes::String>::className() == "java/lang/String"); static_assert(QtJniTypes::Traits<QtJniTypes::String>::signature() == "Ljava/lang/String;"); @@ -72,6 +71,16 @@ static_assert(QtJniTypes::Traits<QtJniTypes::String[]>::signature() == "[Ljava/l Q_DECLARE_JNI_CLASS(QtTextToSpeech, "org/qtproject/qt/android/speech/QtTextToSpeech") static_assert(QtJniTypes::Traits<QtJniTypes::QtTextToSpeech>::className() == "org/qtproject/qt/android/speech/QtTextToSpeech"); +// declaring two types Size in different packages +Q_DECLARE_JNI_CLASS(android, util, Size) +Q_DECLARE_JNI_CLASS(org, qtproject, android, Size) + +static_assert(QtJniTypes::Traits<QtJniTypes::android::util::Size>::className() == "android/util/Size"); +static_assert(QtJniTypes::Traits<QtJniTypes::org::qtproject::android::Size>::className() == "org/qtproject/android/Size"); + +using namespace QtJniTypes::org::qtproject; +static_assert(QtJniTypes::Traits<android::Size>::className() == "org/qtproject/android/Size"); + static_assert(QtJniTypes::fieldSignature<jint>() == "I"); static_assert(QtJniTypes::fieldSignature<jint[]>() == "[I"); static_assert(QtJniTypes::fieldSignature<jint>() != "X"); diff --git a/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp b/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp index e67bab7da4..3bf6211a53 100644 --- a/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp +++ b/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp @@ -335,7 +335,7 @@ void tst_QMetaProperty::conversion() void tst_QMetaProperty::enumsFlags() { // QTBUG-83689, verify that enumerations and flags can be assigned from int, - // which is important for Qt Designer. + // which is important for Qt Widgets Designer. EnumFlagsTester t; auto mo = t.metaObject(); diff --git a/tests/auto/corelib/kernel/qpointer/CMakeLists.txt b/tests/auto/corelib/kernel/qpointer/CMakeLists.txt index b1570b8cef..0b2c4b7e45 100644 --- a/tests/auto/corelib/kernel/qpointer/CMakeLists.txt +++ b/tests/auto/corelib/kernel/qpointer/CMakeLists.txt @@ -20,6 +20,7 @@ qt_internal_add_test(tst_qpointer tst_qpointer.cpp LIBRARIES Qt::Gui + Qt::TestPrivate ) ## Scopes: diff --git a/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp b/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp index 7365fee819..b88f1b5b0f 100644 --- a/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp +++ b/tests/auto/corelib/kernel/qpointer/tst_qpointer.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QTest> +#include <QtTest/private/qcomparisontesthelper_p.h> #include <QRunnable> #include <QThreadPool> @@ -23,6 +24,7 @@ private slots: void conversion(); void destructor(); void assignment_operators(); + void compareCompiles(); void equality_operators(); void swap(); void isNull(); @@ -203,12 +205,21 @@ void tst_QPointer::assignment_operators() delete object; } +void tst_QPointer::compareCompiles() +{ + QTestPrivate::testEqualityOperatorsCompile<QPointer<QObject>>(); + QTestPrivate::testEqualityOperatorsCompile<QPointer<QObject>, QObject*>(); + QTestPrivate::testEqualityOperatorsCompile<QPointer<QObject>, QWidget*>(); + QTestPrivate::testEqualityOperatorsCompile<QPointer<QObject>, QPointer<QWidget>>(); + QTestPrivate::testEqualityOperatorsCompile<QPointer<QObject>, std::nullptr_t>(); +} + void tst_QPointer::equality_operators() { QPointer<QObject> p1; QPointer<QObject> p2; - QVERIFY(p1 == p2); + QT_TEST_EQUALITY_OPS(p1, p2, true); QObject *object = nullptr; #ifndef QT_NO_WIDGETS @@ -216,16 +227,15 @@ void tst_QPointer::equality_operators() #endif p1 = object; - QVERIFY(p1 == p2); - QVERIFY(p1 == object); + QT_TEST_EQUALITY_OPS(p1, p2, true); + QT_TEST_EQUALITY_OPS(p1, object, true); p2 = object; - QVERIFY(p2 == p1); - QVERIFY(p2 == object); - + QT_TEST_EQUALITY_OPS(p2, p1, true); + QT_TEST_EQUALITY_OPS(p2, object, true); p1 = this; - QVERIFY(p1 != p2); + QT_TEST_EQUALITY_OPS(p1, p2, false); p2 = p1; - QVERIFY(p1 == p2); + QT_TEST_EQUALITY_OPS(p1, p2, true); // compare to zero p1 = nullptr; @@ -233,19 +243,13 @@ void tst_QPointer::equality_operators() QVERIFY(0 == p1); QVERIFY(p2 != 0); QVERIFY(0 != p2); - QVERIFY(p1 == nullptr); - QVERIFY(nullptr == p1); - QVERIFY(p2 != nullptr); - QVERIFY(nullptr != p2); - QVERIFY(p1 == object); - QVERIFY(object == p1); - QVERIFY(p2 != object); - QVERIFY(object != p2); + QT_TEST_EQUALITY_OPS(p1, nullptr, true); + QT_TEST_EQUALITY_OPS(p2, nullptr, false); + QT_TEST_EQUALITY_OPS(p1, object, true); + QT_TEST_EQUALITY_OPS(p2, object, false); #ifndef QT_NO_WIDGETS - QVERIFY(p1 == widget); - QVERIFY(widget == p1); - QVERIFY(p2 != widget); - QVERIFY(widget != p2); + QT_TEST_EQUALITY_OPS(p1, widget, true); + QT_TEST_EQUALITY_OPS(p2, widget, false); #endif } diff --git a/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp b/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp index c76500ea11..f214572cfa 100644 --- a/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp +++ b/tests/auto/corelib/kernel/qtranslator/tst_qtranslator.cpp @@ -27,6 +27,7 @@ private slots: void load_data(); void load(); + void loadLocale_data(); void loadLocale(); void threadLoad(); void testLanguageChange(); @@ -116,12 +117,23 @@ void tst_QTranslator::load() } } +void tst_QTranslator::loadLocale_data() +{ + QTest::addColumn<QString>("localeName"); + QTest::addColumn<QStringList>("fileNames"); + + QTest::addRow("US English") + << "en_US" + << QStringList{"en_US.qm", "en_US", "en.qm", "en"}; + QTest::addRow("Australia") + << "en_AU" + << QStringList{"en_Latn_AU.qm", "en_AU.qm", "en.qm"}; +} + void tst_QTranslator::loadLocale() { - QLocale locale; - auto localeName = locale.uiLanguages(QLocale::TagSeparator::Underscore).value(0); - if (localeName.isEmpty()) - QSKIP("This test requires at least one available UI language."); + QFETCH(const QString, localeName); + QFETCH(const QStringList, fileNames); QByteArray ba; { @@ -134,36 +146,16 @@ void tst_QTranslator::loadLocale() QTemporaryDir dir; QVERIFY(dir.isValid()); - auto path = dir.path(); + const auto path = dir.path(); QFile file(path + "/dummy"); QVERIFY2(file.open(QFile::WriteOnly), qPrintable(file.errorString())); QCOMPARE(file.write(ba), ba.size()); file.close(); - /* - Test the following order: - - /tmp/tmpDir/foo-en_US.qm - /tmp/tmpDir/foo-en_US - /tmp/tmpDir/foo-en.qm - /tmp/tmpDir/foo-en - /tmp/tmpDir/foo.qm - /tmp/tmpDir/foo- - /tmp/tmpDir/foo - */ - QStringList files; - while (true) { - files.append(path + "/foo-" + localeName + ".qm"); - QVERIFY2(file.copy(files.last()), qPrintable(file.errorString())); - - files.append(path + "/foo-" + localeName); + for (const auto &fileName : fileNames) { + files.append(path + "/foo-" + fileName); QVERIFY2(file.copy(files.last()), qPrintable(file.errorString())); - - int rightmost = localeName.lastIndexOf(QLatin1Char('_')); - if (rightmost <= 0) - break; - localeName.truncate(rightmost); } files.append(path + "/foo.qm"); @@ -175,10 +167,14 @@ void tst_QTranslator::loadLocale() files.append(path + "/foo"); QVERIFY2(file.rename(files.last()), qPrintable(file.errorString())); + QLocale locale(localeName); QTranslator tor; for (const auto &filePath : files) { QVERIFY(tor.load(locale, "foo", "-", path, ".qm")); - QCOMPARE(tor.filePath(), filePath); + // As the file system might be case insensitive, we can't guarantee that + // the casing of the file name is preserved. The order of loading + // en_AU vs en_au if both exist is undefined anyway. + QCOMPARE(tor.filePath().toLower(), filePath.toLower()); QVERIFY2(file.remove(filePath), qPrintable(file.errorString())); } } diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp index 23d41cafb2..d79e0e82f8 100644 --- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp +++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp @@ -5,6 +5,8 @@ #include <qvariant.h> +#include <QtCore/qttypetraits.h> + // don't assume <type_traits> template <typename T, typename U> constexpr inline bool my_is_same_v = false; @@ -544,6 +546,9 @@ void tst_QVariant::isNull() var3 = QVariant(QMetaType::fromType<QString>()); QVERIFY( var3.isNull() ); + var3.setValue(QString()); + QVERIFY( !var3.isNull() ); + QVariant var4( 0 ); QVERIFY( !var4.isNull() ); diff --git a/tests/auto/corelib/platform/windows/qcomobject/tst_qcomobject.cpp b/tests/auto/corelib/platform/windows/qcomobject/tst_qcomobject.cpp index 5ad961ee66..3c609238fc 100644 --- a/tests/auto/corelib/platform/windows/qcomobject/tst_qcomobject.cpp +++ b/tests/auto/corelib/platform/windows/qcomobject/tst_qcomobject.cpp @@ -69,6 +69,7 @@ struct QComObjectTraits<IDirect> }; } // namespace QtPrivate +QT_END_NAMESPACE class tst_QComObject : public QObject { @@ -263,6 +264,4 @@ void tst_QComObject::Release_decrementsReferenceCountByOne() QTEST_MAIN(tst_QComObject) # include "tst_qcomobject.moc" -QT_END_NAMESPACE - #endif // Q_OS_WIN diff --git a/tests/auto/corelib/plugin/qplugin/tst_qplugin.cpp b/tests/auto/corelib/plugin/qplugin/tst_qplugin.cpp index 3d3cb8330d..9443ba9e5c 100644 --- a/tests/auto/corelib/plugin/qplugin/tst_qplugin.cpp +++ b/tests/auto/corelib/plugin/qplugin/tst_qplugin.cpp @@ -49,7 +49,7 @@ void tst_QPlugin::initTestCase() void tst_QPlugin::loadDebugPlugin() { - const auto fileNames = dir.entryList(QStringList() << "*debug*", QDir::Files); + const auto fileNames = dir.entryList(QStringList() << "*debugplugin*", QDir::Files); if (fileNames.isEmpty()) QSKIP("No debug plugins found - skipping test"); @@ -82,7 +82,7 @@ void tst_QPlugin::loadDebugPlugin() void tst_QPlugin::loadReleasePlugin() { - const auto fileNames = dir.entryList(QStringList() << "*release*", QDir::Files); + const auto fileNames = dir.entryList(QStringList() << "*releaseplugin*", QDir::Files); if (fileNames.isEmpty()) QSKIP("No release plugins found - skipping test"); @@ -180,7 +180,7 @@ void tst_QPlugin::scanInvalidPlugin() #if defined(Q_OS_MACOS) && defined(Q_PROCESSOR_ARM) QSKIP("This test crashes on ARM macOS"); #endif - const auto fileNames = dir.entryList({"*invalid*"}, QDir::Files); + const auto fileNames = dir.entryList({"*invalidplugin*"}, QDir::Files); QString invalidPluginName; if (fileNames.isEmpty()) QSKIP("No invalid plugin found - skipping test"); diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/CMakeLists.txt b/tests/auto/corelib/plugin/qpluginloader/machtest/CMakeLists.txt index 6cb69fc46d..daf922b42c 100644 --- a/tests/auto/corelib/plugin/qpluginloader/machtest/CMakeLists.txt +++ b/tests/auto/corelib/plugin/qpluginloader/machtest/CMakeLists.txt @@ -1,3 +1,5 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause set_directory_properties(PROPERTIES _qt_good_targets "" _qt_stub_targets "" diff --git a/tests/auto/corelib/plugin/qpluginloader/machtest/stub.cpp b/tests/auto/corelib/plugin/qpluginloader/machtest/stub.cpp index 24bac391fb..eed7228a29 100644 --- a/tests/auto/corelib/plugin/qpluginloader/machtest/stub.cpp +++ b/tests/auto/corelib/plugin/qpluginloader/machtest/stub.cpp @@ -1 +1,3 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only void dummy() {} 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/tst_quuid.cpp b/tests/auto/corelib/plugin/quuid/tst_quuid.cpp index c5ce490b61..6d149c08db 100644 --- a/tests/auto/corelib/plugin/quuid/tst_quuid.cpp +++ b/tests/auto/corelib/plugin/quuid/tst_quuid.cpp @@ -3,6 +3,8 @@ #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(); @@ -33,6 +36,8 @@ private slots: void equal(); void notEqual(); void cpp11(); + void ordering_data(); + void ordering(); // Only in Qt > 3.2.x void generate(); @@ -89,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(nullptr)); + 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() @@ -162,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() @@ -196,27 +209,30 @@ 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() @@ -234,15 +250,15 @@ void tst_QUuid::id128() 0xba, 0x47, 0xec, 0x7e, 0x99, 0x03, 0x9a, 0x7b, } }; - QCOMPARE(QUuid(bytesA), uuidA); - QCOMPARE(QUuid(bytesB), uuidB); + 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]; - QCOMPARE(QUuid(leBytesA, QSysInfo::LittleEndian), uuidA); + 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 @@ -271,16 +287,16 @@ void tst_QUuid::uint128() constexpr QUuid uuid = QUuid::fromUInt128(be); static_assert(uuid.toUInt128() == be, "Round-trip through QUuid failed"); - QCOMPARE(uuid, uuidA); + QT_TEST_EQUALITY_OPS(uuid, uuidA, true); QCOMPARE(uuid.toUInt128(), be); quint128 le = qFromBigEndian(be); QCOMPARE(uuid.toUInt128(QSysInfo::LittleEndian), le); - QCOMPARE(QUuid::fromUInt128(le, QSysInfo::LittleEndian), uuidA); + QT_TEST_EQUALITY_OPS(QUuid::fromUInt128(le, QSysInfo::LittleEndian), uuidA, true); QUuid::Id128Bytes bytes = { .data128 = { qToBigEndian(u) } }; QUuid uuid2(bytes); - QCOMPARE(uuid2, uuid); + QT_TEST_EQUALITY_OPS(uuid2, uuid, true); // verify that toBytes() and toUInt128() provide bytewise similar result constexpr quint128 val = uuid.toUInt128(); @@ -294,11 +310,11 @@ void tst_QUuid::uint128() 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() @@ -314,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); @@ -325,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); } } @@ -340,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); } @@ -368,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(); @@ -384,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); @@ -400,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 @@ -407,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); } @@ -512,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() @@ -544,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/serialization/CMakeLists.txt b/tests/auto/corelib/serialization/CMakeLists.txt index 45965114cc..96959ec8f0 100644 --- a/tests/auto/corelib/serialization/CMakeLists.txt +++ b/tests/auto/corelib/serialization/CMakeLists.txt @@ -2,10 +2,15 @@ # SPDX-License-Identifier: BSD-3-Clause add_subdirectory(json) +if (NOT WASM) # QTBUG-121822 add_subdirectory(qcborstreamreader) +endif() if(QT_FEATURE_cborstreamwriter) + if (NOT WASM) # QTBUG-121822 add_subdirectory(qcborstreamwriter) + endif() endif() +# also (but not only!) QTBUG-121822: if(NOT WASM) add_subdirectory(qcborvalue) endif() diff --git a/tests/auto/corelib/serialization/qcborstreamreader/CMakeLists.txt b/tests/auto/corelib/serialization/qcborstreamreader/CMakeLists.txt index 29a935977b..af6aaf3eab 100644 --- a/tests/auto/corelib/serialization/qcborstreamreader/CMakeLists.txt +++ b/tests/auto/corelib/serialization/qcborstreamreader/CMakeLists.txt @@ -17,6 +17,10 @@ qt_internal_add_test(tst_qcborstreamreader INCLUDE_DIRECTORIES ../../../../../src/3rdparty/tinycbor/src ../../../../../src/3rdparty/tinycbor/tests + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::CorePrivate ) diff --git a/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp b/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp index 63cfbce75f..05e3c7bc23 100644 --- a/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp +++ b/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp @@ -5,6 +5,10 @@ #include <QTest> #include <QBuffer> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + class tst_QCborStreamReader : public QObject { Q_OBJECT @@ -627,8 +631,6 @@ void tst_QCborStreamReader::strings_data() void tst_QCborStreamReader::strings() { fixed(); - if (QTest::currentTestFailed()) - return; // Extra string checks: // We'll compare the reads using readString() and readByteArray() @@ -814,9 +816,6 @@ void tst_QCborStreamReader::arrays() removeIndicators(expected); checkContainer(1, '\x81' + data, '[' + expected + ']'); - if (QTest::currentTestFailed()) - return; - checkContainer(2, '\x82' + data + data, '[' + expected + ", " + expected + ']'); } @@ -828,19 +827,11 @@ void tst_QCborStreamReader::maps() // int keys checkContainer(1, "\xa1\1" + data, "{1: " + expected + '}'); - if (QTest::currentTestFailed()) - return; - checkContainer(2, "\xa2\1" + data + '\x20' + data, "{1: " + expected + ", -1: " + expected + '}'); - if (QTest::currentTestFailed()) - return; // string keys checkContainer(1, "\xa1\x65Hello" + data, "{\"Hello\": " + expected + '}'); - if (QTest::currentTestFailed()) - return; - checkContainer(2, "\xa2\x65World" + data + "\x65Hello" + data, "{\"World\": " + expected + ", \"Hello\": " + expected + '}'); } @@ -852,9 +843,6 @@ void tst_QCborStreamReader::undefLengthArrays() removeIndicators(expected); checkContainer(-1, '\x9f' + data + '\xff', '[' + expected + ']'); - if (QTest::currentTestFailed()) - return; - checkContainer(-2, '\x9f' + data + data + '\xff', '[' + expected + ", " + expected + ']'); } @@ -866,19 +854,11 @@ void tst_QCborStreamReader::undefLengthMaps() // int keys checkContainer(-1, "\xbf\1" + data + '\xff', "{1: " + expected + '}'); - if (QTest::currentTestFailed()) - return; - checkContainer(-2, "\xbf\1" + data + '\x20' + data + '\xff', "{1: " + expected + ", -1: " + expected + '}'); - if (QTest::currentTestFailed()) - return; // string keys checkContainer(-1, "\xbf\x65Hello" + data + '\xff', "{\"Hello\": " + expected + '}'); - if (QTest::currentTestFailed()) - return; - checkContainer(-2, "\xbf\x65World" + data + "\x65Hello" + data + '\xff', "{\"World\": " + expected + ", \"Hello\": " + expected + '}'); } diff --git a/tests/auto/corelib/serialization/qcborstreamwriter/CMakeLists.txt b/tests/auto/corelib/serialization/qcborstreamwriter/CMakeLists.txt index c1a9a87677..7b2428e027 100644 --- a/tests/auto/corelib/serialization/qcborstreamwriter/CMakeLists.txt +++ b/tests/auto/corelib/serialization/qcborstreamwriter/CMakeLists.txt @@ -16,4 +16,8 @@ qt_internal_add_test(tst_qcborstreamwriter tst_qcborstreamwriter.cpp INCLUDE_DIRECTORIES ../../../../../src/3rdparty/tinycbor/tests + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP ) diff --git a/tests/auto/corelib/serialization/qcborstreamwriter/tst_qcborstreamwriter.cpp b/tests/auto/corelib/serialization/qcborstreamwriter/tst_qcborstreamwriter.cpp index 45e241ef5c..a0ce4a93a6 100644 --- a/tests/auto/corelib/serialization/qcborstreamwriter/tst_qcborstreamwriter.cpp +++ b/tests/auto/corelib/serialization/qcborstreamwriter/tst_qcborstreamwriter.cpp @@ -5,6 +5,10 @@ #include <QCborStreamWriter> #include <QBuffer> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + class tst_QCborStreamWriter : public QObject { Q_OBJECT @@ -247,18 +251,10 @@ void tst_QCborStreamWriter::arrays() QFETCH(QByteArray, output); compare(make_list(input), "\x81" + output); - if (QTest::currentTestFailed()) - return; - compare(make_list(input, input), "\x82" + output + output); - if (QTest::currentTestFailed()) - return; // nested lists compare(make_list(make_list(input)), "\x81\x81" + output); - if (QTest::currentTestFailed()) - return; - compare(make_list(make_list(input), make_list(input)), "\x82\x81" + output + "\x81" + output); } @@ -268,9 +264,6 @@ void tst_QCborStreamWriter::maps() QFETCH(QByteArray, output); compare(make_map({{1, input}}), "\xa1\1" + output); - if (QTest::currentTestFailed()) - return; - compare(make_map({{1, input}, {input, 24}}), "\xa2\1" + output + output + "\x18\x18"); } diff --git a/tests/auto/corelib/serialization/qcborvalue/CMakeLists.txt b/tests/auto/corelib/serialization/qcborvalue/CMakeLists.txt index 4b72396489..089677aacb 100644 --- a/tests/auto/corelib/serialization/qcborvalue/CMakeLists.txt +++ b/tests/auto/corelib/serialization/qcborvalue/CMakeLists.txt @@ -17,6 +17,10 @@ qt_internal_add_test(tst_qcborvalue INCLUDE_DIRECTORIES ../../../../../src/3rdparty/tinycbor/src ../../../../../src/3rdparty/tinycbor/tests/parser + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::CorePrivate Qt::TestPrivate diff --git a/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp b/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp index e480b033e1..04d90bcf9d 100644 --- a/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp +++ b/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp @@ -14,6 +14,10 @@ #include <QtEndian> #include <QTimeZone> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + Q_DECLARE_METATYPE(QCborKnownTags) Q_DECLARE_METATYPE(QCborValue) Q_DECLARE_METATYPE(QCborValue::EncodingOptions) @@ -1348,8 +1352,6 @@ void tst_QCborValue::arrayValueRef() }; iteratorCheck(a.begin()); - if (QTest::currentTestFailed()) - return; iteratorCheck(a.constBegin()); } @@ -1412,8 +1414,6 @@ void tst_QCborValue::mapValueRef() }; iteratorCheck(m.begin()); - if (QTest::currentTestFailed()) - return; iteratorCheck(m.constBegin()); } @@ -2410,53 +2410,29 @@ void fromCbor_common(void (*doCheck)(const QCborValue &, const QByteArray &)) QFETCH(QByteArray, result); doCheck(v, result); - if (QTest::currentTestFailed()) - return; // in an array doCheck(QCborArray{v}, "\x81" + result); - if (QTest::currentTestFailed()) - return; - doCheck(QCborArray{v, v}, "\x82" + result + result); - if (QTest::currentTestFailed()) - return; // in a map doCheck(QCborMap{{1, v}}, "\xa1\1" + result); - if (QTest::currentTestFailed()) - return; // undefined-length arrays and maps doCheck(QCborArray{v}, "\x9f" + result + "\xff"); - if (QTest::currentTestFailed()) - return; doCheck(QCborArray{v, v}, "\x9f" + result + result + "\xff"); - if (QTest::currentTestFailed()) - return; doCheck(QCborMap{{1, v}}, "\xbf\1" + result + "\xff"); - if (QTest::currentTestFailed()) - return; // tagged QCborValue t(QCborKnownTags::Signature, v); doCheck(t, "\xd9\xd9\xf7" + result); - if (QTest::currentTestFailed()) - return; // in an array doCheck(QCborArray{t}, "\x81\xd9\xd9\xf7" + result); - if (QTest::currentTestFailed()) - return; - doCheck(QCborArray{t, t}, "\x82\xd9\xd9\xf7" + result + "\xd9\xd9\xf7" + result); - if (QTest::currentTestFailed()) - return; // in a map doCheck(QCborMap{{1, t}}, "\xa1\1\xd9\xd9\xf7" + result); - if (QTest::currentTestFailed()) - return; } void tst_QCborValue::fromCbor() @@ -3116,14 +3092,9 @@ void tst_QCborValue::cborValueRefMutatingMapIntKey() }; // accessing a negative index causes it to become a map executeTest(-1); - if (QTest::currentTestFailed()) - return; // if the index is bigger than 0x10000, the array becomes a map executeTest(0x10000); - if (QTest::currentTestFailed()) - return; - if (type != QCborValue::Array) executeTest(5); } diff --git a/tests/auto/corelib/text/CMakeLists.txt b/tests/auto/corelib/text/CMakeLists.txt index 099f0e7eef..bee0c5cf44 100644 --- a/tests/auto/corelib/text/CMakeLists.txt +++ b/tests/auto/corelib/text/CMakeLists.txt @@ -1,7 +1,9 @@ # Copyright (C) 2022 The Qt Company Ltd. # SPDX-License-Identifier: BSD-3-Clause +if (NOT WASM) # QTBUG-121822 add_subdirectory(qanystringview) +endif() add_subdirectory(qbytearray) add_subdirectory(qbytearray_large) add_subdirectory(qbytearrayapisymmetry) @@ -13,7 +15,9 @@ add_subdirectory(qchar) add_subdirectory(qcollator) add_subdirectory(qlatin1stringmatcher) add_subdirectory(qlatin1stringview) +if (NOT WASM) # QTBUG-121822 add_subdirectory(qregularexpression) +endif() add_subdirectory(qstring) add_subdirectory(qstring_no_cast_from_bytearray) add_subdirectory(qstringapisymmetry) diff --git a/tests/auto/corelib/text/qanystringview/CMakeLists.txt b/tests/auto/corelib/text/qanystringview/CMakeLists.txt index 96837dadf6..894115d1c2 100644 --- a/tests/auto/corelib/text/qanystringview/CMakeLists.txt +++ b/tests/auto/corelib/text/qanystringview/CMakeLists.txt @@ -14,6 +14,10 @@ endif() qt_internal_add_test(tst_qanystringview SOURCES tst_qanystringview.cpp + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::CorePrivate Qt::TestPrivate diff --git a/tests/auto/corelib/text/qanystringview/tst_qanystringview.cpp b/tests/auto/corelib/text/qanystringview/tst_qanystringview.cpp index 0eaadb870c..51ea3025ab 100644 --- a/tests/auto/corelib/text/qanystringview/tst_qanystringview.cpp +++ b/tests/auto/corelib/text/qanystringview/tst_qanystringview.cpp @@ -28,6 +28,10 @@ #include <deque> #include <list> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + #ifdef __cpp_char8_t # define ONLY_IF_CHAR_8_T(expr) expr #else @@ -356,6 +360,25 @@ private Q_SLOTS: fromLiteral(u8"Hello, World!"); // char[] in <= C++17, char8_t[] in >= C++20 } + void fromChar() const { fromCharacter('\xE4', 1); } + void fromUChar() const { fromCharacter(static_cast<unsigned char>('\xE4'), 1); } + void fromSChar() const { fromCharacter(static_cast<signed char>('\xE4'), 1); } + void fromChar16T() const { fromCharacter(u'ä', 1); } + void fromUShort() const { fromCharacter(ushort(0xE4), 1); } + void fromChar32T() const { + fromCharacter(U'ä', 1); + fromCharacter(U'\x1F0A0', 2); // U+1F0A0: PLAYING CARD BACK + } + void fromWCharT() const { + ONLY_WIN(fromCharacter(L'ä', 1)); // should work on Unix, too (char32_t does) + } + void fromQChar() const { fromCharacter(QChar(u'ä'), 1); } + void fromQLatin1Char() const { fromCharacter(QLatin1Char('\xE4'), 1); } + void fromQCharSpecialCharacter() const { + fromCharacter(QChar::ReplacementCharacter, 1); + fromCharacter(QChar::LastValidCodePoint, 1); + } + void fromChar16TStar() const { fromLiteral(u"Hello, World!"); } void fromWCharTStar() const { ONLY_WIN(fromLiteral(L"Hello, World!")); } @@ -393,6 +416,8 @@ private: template <typename Char> void fromLiteral(const Char *arg) const; template <typename Char> + void fromCharacter(Char arg, qsizetype expectedSize) const; + template <typename Char> void fromRange() const; template <typename Char, typename Container> void fromContainer() const; @@ -636,20 +661,10 @@ void tst_QAnyStringView::fromQStringOrByteArray() const QVERIFY(!QAnyStringView(empty).isNull()); conversion_tests(QStringOrByteArray(Strings::oneChar)); - if (QTest::currentTestFailed()) - return; conversion_tests(QStringOrByteArray(Strings::twoChars)); - if (QTest::currentTestFailed()) - return; conversion_tests(QStringOrByteArray(Strings::threeChars)); - if (QTest::currentTestFailed()) - return; conversion_tests(QStringOrByteArray(Strings::regularString)); - if (QTest::currentTestFailed()) - return; conversion_tests(QStringOrByteArray(Strings::regularLongString)); - if (QTest::currentTestFailed()) - return; conversion_tests(QStringOrByteArray(Strings::stringWithNulls, Strings::stringWithNullsLength)); } @@ -673,6 +688,44 @@ void tst_QAnyStringView::fromLiteral(const Char *arg) const conversion_tests(arg); } +template<typename Char> +void tst_QAnyStringView::fromCharacter(Char arg, qsizetype expectedSize) const +{ + // Need to re-create a new QASV(arg) each time, QASV(Char).data() dangles + // after the end of the Full Expression: + + static_assert(noexcept(QAnyStringView(arg)), + "If this fails, we may be creating a temporary QString/QByteArray"); + + QCOMPARE(QAnyStringView(arg).size(), expectedSize); + + // QCOMPARE(QAnyStringView(arg), arg); // not all pairs compile, so do it manually: + + // Check implicit conversion: + const QChar chars[] = { + [](QAnyStringView v) { return v.front(); }(arg), + [](QAnyStringView v) { return v.back(); }(arg), + }; + + switch (expectedSize) { + case 1: + if constexpr (std::is_same_v<Char, signed char>) // QChar doesn't have a ctor for this + QCOMPARE(chars[0], QChar(uchar(arg))); + else + QCOMPARE(chars[0], QChar(arg)); + break; + case 2: + QCOMPARE_EQ(QAnyStringView(arg), QStringView::fromArray(chars)); + if constexpr (std::is_convertible_v<Char, char32_t>) + QCOMPARE_EQ(QAnyStringView(arg), QStringView(QChar::fromUcs4(arg))); + break; + default: + QFAIL("Don't know how to compare this type to QAnyStringView"); + } + + // conversion_tests() would produce dangling references +} + template <typename Char> void tst_QAnyStringView::fromRange() const { @@ -697,18 +750,10 @@ void tst_QAnyStringView::fromRange() const doTest(reinterpret_cast<const Char *>(std::begin(Strings::regularString)), reinterpret_cast<const Char *>(std::end(Strings::regularString))); - if (QTest::currentTestFailed()) - return; - doTest(reinterpret_cast<const Char *>(std::begin(Strings::regularLongString)), reinterpret_cast<const Char *>(std::end(Strings::regularLongString))); - if (QTest::currentTestFailed()) - return; - doTest(reinterpret_cast<const Char *>(std::begin(Strings::stringWithNulls)), reinterpret_cast<const Char *>(std::end(Strings::stringWithNulls))); - if (QTest::currentTestFailed()) - return; } template <typename Char, typename Container> @@ -723,8 +768,6 @@ void tst_QAnyStringView::fromContainer() const std::copy(s.begin(), s.end(), std::back_inserter(c)); conversion_tests(std::move(c)); - if (QTest::currentTestFailed()) - return; // repeat with nulls c = {}; diff --git a/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt b/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt index c78a81c7bd..8922ae2267 100644 --- a/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt +++ b/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt @@ -15,3 +15,10 @@ qt_internal_add_test(tst_qbytearrayview SOURCES tst_qbytearrayview.cpp ) + +if(QT_FEATURE_sanitize_undefined) + qt_internal_extend_target(tst_qbytearrayview + DEFINES + QT_SANITIZE_UNDEFINED # GCC (in)famously doesn't provide a predefined macro for this + ) +endif() diff --git a/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp b/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp index 894f0430dd..702e1840da 100644 --- a/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp +++ b/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp @@ -262,10 +262,9 @@ void tst_QByteArrayView::constExpr() const static_assert(!bv2.empty()); static_assert(bv2.size() == 5); } -#if !defined(Q_CC_GNU) || defined(Q_CC_CLANG) +#if !defined(Q_CC_GNU_ONLY) || !defined(QT_SANITIZE_UNDEFINED) // Below checks are disabled because of a compilation issue with GCC and // -fsanitize=undefined. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71962. - // Note: Q_CC_GNU is also defined for Clang, so we need to check that too. { static constexpr char hello[] = "Hello"; constexpr QByteArrayView bv(hello); @@ -307,6 +306,9 @@ void tst_QByteArrayView::constExpr() const static_assert(bv.back() == 'o'); static_assert(bv.last() == 'o'); + constexpr auto bv2 = QByteArrayView::fromArray(hello); + QCOMPARE_EQ(bv, bv2); + constexpr std::string_view sv = bv; static_assert(bv.size() == sv.size()); #ifdef AMBIGUOUS_CALL // QTBUG-108805 @@ -416,7 +418,7 @@ void tst_QByteArrayView::fromArray() const { static constexpr char hello[] = "Hello\0abc\0\0."; - constexpr QByteArrayView bv = QByteArrayView::fromArray(hello); + const QByteArrayView bv = QByteArrayView::fromArray(hello); QCOMPARE(bv.size(), 13); QVERIFY(!bv.empty()); QVERIFY(!bv.isEmpty()); diff --git a/tests/auto/corelib/text/qlocale/tst_qlocale.cpp b/tests/auto/corelib/text/qlocale/tst_qlocale.cpp index c9668cd4d4..eb2d73b9b2 100644 --- a/tests/auto/corelib/text/qlocale/tst_qlocale.cpp +++ b/tests/auto/corelib/text/qlocale/tst_qlocale.cpp @@ -4178,6 +4178,8 @@ void tst_QLocale::mySystemLocale() qDebug("\n\t%s", qPrintable(QLocale::system().uiLanguages().join(u"\n\t"))); }); QCOMPARE(QLocale::system().uiLanguages(), uiLanguages); + QCOMPARE(QLocale::system().uiLanguages(QLocale::TagSeparator::Underscore), + uiLanguages.replaceInStrings(u"-", u"_")); reporter.dismiss(); } diff --git a/tests/auto/corelib/text/qregularexpression/CMakeLists.txt b/tests/auto/corelib/text/qregularexpression/CMakeLists.txt index a7a7fe298f..2c67a16184 100644 --- a/tests/auto/corelib/text/qregularexpression/CMakeLists.txt +++ b/tests/auto/corelib/text/qregularexpression/CMakeLists.txt @@ -14,6 +14,10 @@ endif() qt_internal_add_test(tst_qregularexpression SOURCES tst_qregularexpression.cpp + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP LIBRARIES Qt::TestPrivate ) diff --git a/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp b/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp index d0ce414095..53a6d83d50 100644 --- a/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp +++ b/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp @@ -16,6 +16,10 @@ #include <iostream> #include <optional> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + Q_DECLARE_METATYPE(QRegularExpression::PatternOptions) Q_DECLARE_METATYPE(QRegularExpression::MatchType) Q_DECLARE_METATYPE(QRegularExpression::MatchOptions) @@ -292,11 +296,7 @@ void consistencyCheck(const QRegularExpressionMatchIterator &iterator) QRegularExpressionMatch peeked = i.peekNext(); QRegularExpressionMatch match = i.next(); consistencyCheck(peeked); - if (QTest::currentTestFailed()) - return; consistencyCheck(match); - if (QTest::currentTestFailed()) - return; QVERIFY(match.isValid()); QVERIFY(match.hasMatch() || match.hasPartialMatch()); QCOMPARE(i.regularExpression(), match.regularExpression()); @@ -544,8 +544,6 @@ void tst_QRegularExpression::moveSemanticsMatch() QCOMPARE(match2.capturedStart(), 3); QCOMPARE(match2.capturedEnd(), 7); consistencyCheck(match2); - if (QTest::currentTestFailed()) - return; QRegularExpressionMatch match3 = re.match("test1"); QCOMPARE(match3.hasMatch(), true); @@ -558,8 +556,6 @@ void tst_QRegularExpression::moveSemanticsMatch() QCOMPARE(match1.capturedStart(), 0); QCOMPARE(match1.capturedEnd(), 4); consistencyCheck(match1); - if (QTest::currentTestFailed()) - return; // here match3 is in the moved-from state, so destructor call for moved-from // object is also checked @@ -578,8 +574,6 @@ void tst_QRegularExpression::moveSemanticsMatchIterator() QVERIFY(it2.hasNext()); QT_TEST_EQUALITY_OPS(it2.regularExpression(), re, true); consistencyCheck(it2); - if (QTest::currentTestFailed()) - return; QRegularExpression re2("test"); QRegularExpressionMatchIterator it3 = re2.globalMatch("123test456"); @@ -593,8 +587,6 @@ void tst_QRegularExpression::moveSemanticsMatchIterator() QVERIFY(it1.hasNext()); QT_TEST_EQUALITY_OPS(it1.regularExpression(), re2, true); consistencyCheck(it1); - if (QTest::currentTestFailed()) - return; // here it3 is in the moved-from state, so destructor call for moved-from // object is also checked diff --git a/tests/auto/corelib/text/qstring/tst_qstring.cpp b/tests/auto/corelib/text/qstring/tst_qstring.cpp index d56a9ebd20..92ea5b013d 100644 --- a/tests/auto/corelib/text/qstring/tst_qstring.cpp +++ b/tests/auto/corelib/text/qstring/tst_qstring.cpp @@ -6647,9 +6647,41 @@ void tst_QString::arg() // number overloads QCOMPARE( s4.arg(0), QLatin1String("[0]") ); QCOMPARE( s4.arg(-1), QLatin1String("[-1]") ); + QCOMPARE( s4.arg(0U), QLatin1String("[0]")); + QCOMPARE( s4.arg(qint8(-128)), QLatin1String("[-128]")); // signed char + QCOMPARE( s4.arg(quint8(255)), QLatin1String("[255]")); // unsigned char + QCOMPARE( s4.arg(short(-4200)), QLatin1String("[-4200]")); + QCOMPARE( s4.arg(ushort(42000)), QLatin1String("[42000]")); QCOMPARE( s4.arg(4294967295UL), QLatin1String("[4294967295]") ); // ULONG_MAX 32 QCOMPARE( s4.arg(Q_INT64_C(9223372036854775807)), // LLONG_MAX QLatin1String("[9223372036854775807]") ); + QCOMPARE( s4.arg(Q_UINT64_C(9223372036854775808)), // LLONG_MAX + 1 + QLatin1String("[9223372036854775808]") ); + + // FP overloads + QCOMPARE(s4.arg(2.25), QLatin1String("[2.25]")); + QCOMPARE(s4.arg(3.75f), QLatin1String("[3.75]")); +#if !QFLOAT16_IS_NATIVE // QTBUG-126055 + QCOMPARE(s4.arg(qfloat16{4.125f}), QLatin1String("[4.125]")); +#endif + + // char-ish overloads + QCOMPARE(s4.arg('\xE4'), QStringView(u"[ä]")); + QEXPECT_FAIL("", "QTBUG-125588", Continue); + QCOMPARE(s4.arg(u'ø'), QStringView(u"[ø]")); +#ifdef Q_OS_WIN + QCOMPARE(QLatin1String("[%1]").arg(L'ø'), QStringView(u"[ø]")); +#endif + QEXPECT_FAIL("", "QTBUG-126054", Continue); + QCOMPARE(s4.arg(L'ø'), QStringView(u"[ø]")); +#ifndef __cpp_char8_t +#ifndef QT_NO_CAST_FROM_ASCII + QCOMPARE(QLatin1String("[%1]").arg(u8'a'), QLatin1String("[a]")); +#endif +#else + QEXPECT_FAIL("", "QTBUG-126053", Continue); +#endif + QCOMPARE(s4.arg(u8'a'), QLatin1String("[a]")); QTest::ignoreMessage(QtWarningMsg, "QString::arg: Argument missing: , foo"); QCOMPARE(QString().arg(foo), QString()); diff --git a/tests/auto/corelib/text/qstringapisymmetry/tst_qstringapisymmetry.cpp b/tests/auto/corelib/text/qstringapisymmetry/tst_qstringapisymmetry.cpp index 35a734cf02..06ef1aede0 100644 --- a/tests/auto/corelib/text/qstringapisymmetry/tst_qstringapisymmetry.cpp +++ b/tests/auto/corelib/text/qstringapisymmetry/tst_qstringapisymmetry.cpp @@ -545,6 +545,93 @@ private Q_SLOTS: void endsWith_QLatin1String_QLatin1Char() { endsWith_impl<QLatin1String, QLatin1Char>(); } private: + void arg1_data(bool argHasVariableLength = true) const; + template <typename Format, typename Argument> void arg1_impl() const; + +private Q_SLOTS: + // let Formats = {QString, QStringView, QLatin1String} + // let Arguments = Formats ∪ {QByteArray, const char*, const char8_t*. const char16_t*, std::u16string, char, QChar, QLatin1Char, char16_t} + // test Formats × Arguments: + void arg1_QString_QString_data() { arg1_data(); } + void arg1_QString_QString() { arg1_impl<QString, QString>(); } + void arg1_QString_QStringView_data() { arg1_data(); } + void arg1_QString_QStringView() { arg1_impl<QString, QStringView>(); } + void arg1_QString_QLatin1StringView_data() { arg1_data(); } + void arg1_QString_QLatin1StringView() { arg1_impl<QString, QLatin1StringView>(); } + void arg1_QString_QByteArray_data() { arg1_data(); } + void arg1_QString_QByteArray() { arg1_impl<QString, QByteArray>(); } + void arg1_QString_const_char_star_data() { arg1_data(); } + void arg1_QString_const_char_star() { arg1_impl<QString, const char*>(); } + void arg1_QString_const_char8_t_star_data() { arg1_data(); } + void arg1_QString_const_char8_t_star() { IF_CHAR8T((arg1_impl<QString, const char8_t*>())); } + void arg1_QString_const_char16_t_star_data() { arg1_data(); } + void arg1_QString_const_char16_t_star() { arg1_impl<QString, const char16_t*>(); } + void arg1_QString_stdu16string_data() { arg1_data(); } + void arg1_QString_stdu16string() { arg1_impl<QString, std::u16string>(); } + void arg1_QString_char_data() { arg1_data(false); } + void arg1_QString_char() { arg1_impl<QString, char>(); } + void arg1_QString_QChar_data() { arg1_data(false); } + void arg1_QString_QChar() { arg1_impl<QString, QChar>(); } + void arg1_QString_QLatin1Char_data() { arg1_data(false); } + void arg1_QString_QLatin1Char() { arg1_impl<QString, QLatin1Char>(); } + void arg1_QString_char16_t_data() { arg1_data(false); } + void arg1_QString_char16_t() { + QEXPECT_FAIL("%1/a", "QTBUG-125588", Continue); + QEXPECT_FAIL("%1/ä", "QTBUG-125588", Continue); + arg1_impl<QString, char16_t>(); + } + + void arg1_QStringView_QString_data() { arg1_data(); } + void arg1_QStringView_QString() { arg1_impl<QStringView, QString>(); } + void arg1_QStringView_QStringView_data() { arg1_data(); } + void arg1_QStringView_QStringView() { arg1_impl<QStringView, QStringView>(); } + void arg1_QStringView_QLatin1StringView_data() { arg1_data(); } + void arg1_QStringView_QLatin1StringView() { arg1_impl<QStringView, QLatin1StringView>(); } + void arg1_QStringView_QByteArray_data() { arg1_data(); } + void arg1_QStringView_QByteArray() { arg1_impl<QStringView, QByteArray>(); } + void arg1_QStringView_const_char_star_data() { arg1_data(); } + void arg1_QStringView_const_char_star() { arg1_impl<QStringView, const char*>(); } + void arg1_QStringView_const_char8_t_star_data() { arg1_data(); } + void arg1_QStringView_const_char8_t_star() { IF_CHAR8T((arg1_impl<QStringView, const char8_t*>())); } + void arg1_QStringView_const_char16_t_star_data() { arg1_data(); } + void arg1_QStringView_const_char16_t_star() { arg1_impl<QStringView, const char16_t*>(); } + void arg1_QStringView_stdu16string_data() { arg1_data(); } + void arg1_QStringView_stdu16string() { arg1_impl<QStringView, std::u16string>(); } + void arg1_QStringView_char_data() { arg1_data(false); } + void arg1_QStringView_char() { arg1_impl<QStringView, char>(); } + void arg1_QStringView_QChar_data() { arg1_data(false); } + void arg1_QStringView_QChar() { arg1_impl<QStringView, QChar>(); } + void arg1_QStringView_QLatin1Char_data() { arg1_data(false); } + void arg1_QStringView_QLatin1Char() { arg1_impl<QStringView, QLatin1Char>(); } + void arg1_QStringView_char16_t_data() { arg1_data(false); } + void arg1_QStringView_char16_t() { arg1_impl<QStringView, char16_t>(); } + + void arg1_QLatin1StringView_QString_data() { arg1_data(); } + void arg1_QLatin1StringView_QString() { arg1_impl<QLatin1StringView, QString>(); } + void arg1_QLatin1StringView_QStringView_data() { arg1_data(); } + void arg1_QLatin1StringView_QStringView() { arg1_impl<QLatin1StringView, QStringView>(); } + void arg1_QLatin1StringView_QLatin1StringView_data() { arg1_data(); } + void arg1_QLatin1StringView_QLatin1StringView() { arg1_impl<QLatin1StringView, QLatin1StringView>(); } + void arg1_QLatin1StringView_QByteArray_data() { arg1_data(); } + void arg1_QLatin1StringView_QByteArray() { arg1_impl<QLatin1StringView, QByteArray>(); } + void arg1_QLatin1StringView_const_char_star_data() { arg1_data(); } + void arg1_QLatin1StringView_const_char_star() { arg1_impl<QLatin1StringView, const char*>(); } + void arg1_QLatin1StringView_const_char8_t_star_data() { arg1_data(); } + void arg1_QLatin1StringView_const_char8_t_star() { IF_CHAR8T((arg1_impl<QLatin1StringView, const char8_t*>())); } + void arg1_QLatin1StringView_const_char16_t_star_data() { arg1_data(); } + void arg1_QLatin1StringView_const_char16_t_star() { arg1_impl<QLatin1StringView, const char16_t*>(); } + void arg1_QLatin1StringView_stdu16string_data() { arg1_data(); } + void arg1_QLatin1StringView_stdu16string() { arg1_impl<QLatin1StringView, std::u16string>(); } + void arg1_QLatin1StringView_char_data() { arg1_data(false); } + void arg1_QLatin1StringView_char() { arg1_impl<QLatin1StringView, char>(); } + void arg1_QLatin1StringView_QChar_data() { arg1_data(false); } + void arg1_QLatin1StringView_QChar() { arg1_impl<QLatin1StringView, QChar>(); } + void arg1_QLatin1StringView_QLatin1Char_data() { arg1_data(false); } + void arg1_QLatin1StringView_QLatin1Char() { arg1_impl<QLatin1StringView, QLatin1Char>(); } + void arg1_QLatin1StringView_char16_t_data() { arg1_data(false); } + void arg1_QLatin1StringView_char16_t() { arg1_impl<QLatin1StringView, char16_t>(); } + +private: void split_data(bool rhsHasVariableLength = true); template <typename Haystack, typename Needle> void split_impl() const; @@ -1112,6 +1199,10 @@ auto overload_s_v(QStringView s) { return s; } auto overload_sr_v(QString &&s) { return std::move(s); } auto overload_sr_v(QStringView s) { return s; } +Q_WEAK_OVERLOAD +auto overload_s_bav(const QString &s) { return s; } +auto overload_s_bav(QByteArrayView s) { return s; } + } // unnamed namespace template<typename T> @@ -1174,6 +1265,15 @@ void tst_QStringApiSymmetry::overload() overload_sr_v(CT()); } } + + if constexpr (std::is_convertible_v<T, QString> || std::is_convertible_v<T, QByteArrayView>) { + overload_s_bav(t); + overload_s_bav(ct); + if constexpr (!std::is_array_v<T>) { + overload_s_bav(T()); + overload_s_bav(CT()); + } + } QT_WARNING_POP } @@ -1290,6 +1390,7 @@ template <class Str> Str make(QStringView sf, QLatin1String l1, const QByteArra [[maybe_unused]] const QByteArray &u8) \ /*end*/ MAKE(QChar) { return sv.isEmpty() ? QChar() : sv.at(0); } +MAKE(char) { return sv.isEmpty() ? char() : char(sv.at(0).unicode()); } MAKE(char16_t) { return sv.isEmpty() ? char16_t() : char16_t{sv.at(0).unicode()}; } MAKE(QLatin1Char) { return l1.isEmpty() ? QLatin1Char('\0') : l1.at(0); } MAKE(QString) { return sv.toString(); } @@ -1298,6 +1399,9 @@ MAKE(QLatin1String) { return l1; } MAKE(QByteArray) { return u8; } MAKE(QByteArrayView) { return u8; } MAKE(const char *) { return u8.data(); } +#ifdef __cpp_char8_t +MAKE(const char8_t *) { return q_has_char8_t::QUtf8StringView(u8).data(); } +#endif MAKE(const char16_t *) { return sv.utf16(); } // assumes `sv` doesn't represent a substring MAKE(std::u16string) { return sv.toString().toStdU16String(); } MAKE(QUtf8StringView) { return u8; } @@ -1926,6 +2030,69 @@ void tst_QStringApiSymmetry::endsWith_impl() const QCOMPARE_EQ(haystack.endsWith(needle, Qt::CaseInsensitive), resultCIS); } +void tst_QStringApiSymmetry::arg1_data(bool argHasVariableLength) const +{ + QTest::addColumn<QString>("formatU16"); + QTest::addColumn<QString>("argumentU16"); + QTest::addColumn<QString>("expected"); + + const char *null = nullptr; + const char *empty = ""; + + auto row = [](const char *fmt, const char *arg, const char *res) { + auto protect = [](const char *s) { return s ? *s ? s : "<empty>" : "<null>"; }; + QTest::addRow("%s/%s", protect(fmt), protect(arg)) + << QString::fromUtf8(fmt) << QString::fromUtf8(arg) << QString::fromUtf8(res); + }; + + for (auto fmt : {null, empty}) { + if (argHasVariableLength) { + for (auto arg : {null, empty}) + row(fmt, arg, ""); + } + for (auto arg : {"a", "ä"}) + row(fmt, arg, ""); + if (argHasVariableLength) { + for (auto arg : {"äá", "Øåß"}) + row(fmt, arg, ""); + } + } + + for (auto fmt : {"%1"}) { + if (argHasVariableLength) { + for (auto arg : {null, empty}) + row(fmt, arg, arg); + } + for (auto arg : {"a", "ä"}) + row(fmt, arg, arg); + if (argHasVariableLength) { + for (auto arg : {"äá", "Øåß"}) + row(fmt, arg, arg); + } + } +} + +template <typename Format, typename Argument> +void tst_QStringApiSymmetry::arg1_impl() const +{ + QFETCH(const QString, formatU16); + QFETCH(const QString, argumentU16); + QFETCH(const QString, expected); + + const auto formatL1Pinned = formatU16.toLatin1(); + const auto formatL1 = QLatin1StringView{formatL1Pinned}; + const auto formatU8 = formatU16.toUtf8(); + + const auto argumentL1Pinned = argumentU16.toLatin1(); + const auto argumentL1= QLatin1StringView{argumentL1Pinned}; + const auto argumentU8 = argumentU16.toUtf8(); + + const auto format = make<Format>(formatU16, formatL1, formatU8); + const auto argument = make<Argument>(argumentU16, argumentL1, argumentU8); + + QCOMPARE(format.arg(argument), expected); +} + void tst_QStringApiSymmetry::split_data(bool rhsHasVariableLength) { QTest::addColumn<QStringView>("haystackU16"); diff --git a/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/stringbuilder.cpp b/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/stringbuilder.cpp index 59362d010a..7931363b4b 100644 --- a/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/stringbuilder.cpp +++ b/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/stringbuilder.cpp @@ -377,6 +377,8 @@ void runScenario() char chararray[3] = { 'H', 'i', '\0' }; const char constchararray[3] = { 'H', 'i', '\0' }; char achar = 'a'; + char embedded_NULs[16] = { 'H', 'i' }; + const char const_embedded_NULs[16] = { 'H', 'i' }; CHECK(P, bytearray, bytearray); CHECK(P, QByteArray(bytearray), bytearray); @@ -400,6 +402,33 @@ void runScenario() CHECK(P, bytearray, achar); CHECK(Q, bytearray, constchararray); CHECK(Q, bytearray, achar); + CHECK(Q, bytearray, embedded_NULs); + CHECK(Q, bytearray, const_embedded_NULs); + + CHECK(Q, baview, bytearray); + CHECK(Q, baview, charstar); + CHECK(Q, baview, chararray); + CHECK(Q, baview, constchararray); + CHECK(Q, baview, achar); + CHECK(Q, baview, embedded_NULs); + CHECK(Q, baview, const_embedded_NULs); + + // Check QString/QByteArray consistency when appending const char[] with embedded NULs: + { + const QByteArray ba = baview Q embedded_NULs; + QEXPECT_FAIL("", "QTBUG-117321", Continue); + QCOMPARE(ba.size(), baview.size() + q20::ssize(embedded_NULs) - 1); + +#ifndef QT_NO_CAST_FROM_ASCII + const auto l1s = QLatin1StringView{baview}; // l1string != baview + + const QString s = l1s Q embedded_NULs; + QCOMPARE(s.size(), l1s.size() + q20::ssize(embedded_NULs) - 1); + + QEXPECT_FAIL("", "QTBUG-117321", Continue); + QCOMPARE(s, ba); +#endif + } //CHECK(Q, charstar, charstar); // BUILTIN <-> BUILTIN cat't be overloaded //CHECK(Q, charstar, chararray); diff --git a/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/tst_qstringbuilder1.cpp b/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/tst_qstringbuilder1.cpp index 394372c398..e8365f500b 100644 --- a/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/tst_qstringbuilder1.cpp +++ b/tests/auto/corelib/text/qstringbuilder/qstringbuilder1/tst_qstringbuilder1.cpp @@ -15,6 +15,8 @@ #include <QtCore/QStringBuilder> #include <QtTest/QTest> +#include <QtCore/q20iterator.h> + #define LITERAL "some literal" namespace { diff --git a/tests/auto/corelib/text/qstringbuilder/qstringbuilder2/tst_qstringbuilder2.cpp b/tests/auto/corelib/text/qstringbuilder/qstringbuilder2/tst_qstringbuilder2.cpp index dc590304f5..1aaee114a3 100644 --- a/tests/auto/corelib/text/qstringbuilder/qstringbuilder2/tst_qstringbuilder2.cpp +++ b/tests/auto/corelib/text/qstringbuilder/qstringbuilder2/tst_qstringbuilder2.cpp @@ -16,6 +16,8 @@ #include <QtCore/QStringBuilder> #include <QtTest/QTest> +#include <QtCore/q20iterator.h> + #define LITERAL "some literal" namespace { diff --git a/tests/auto/corelib/text/qstringbuilder/qstringbuilder3/tst_qstringbuilder3.cpp b/tests/auto/corelib/text/qstringbuilder/qstringbuilder3/tst_qstringbuilder3.cpp index 3222b52713..aaa14a5d1a 100644 --- a/tests/auto/corelib/text/qstringbuilder/qstringbuilder3/tst_qstringbuilder3.cpp +++ b/tests/auto/corelib/text/qstringbuilder/qstringbuilder3/tst_qstringbuilder3.cpp @@ -15,6 +15,8 @@ #include <QtCore/QStringBuilder> #include <QtTest/QTest> +#include <QtCore/q20iterator.h> + #define LITERAL "some literal" namespace { diff --git a/tests/auto/corelib/text/qstringbuilder/qstringbuilder4/tst_qstringbuilder4.cpp b/tests/auto/corelib/text/qstringbuilder/qstringbuilder4/tst_qstringbuilder4.cpp index 442c5275d2..319708fd4b 100644 --- a/tests/auto/corelib/text/qstringbuilder/qstringbuilder4/tst_qstringbuilder4.cpp +++ b/tests/auto/corelib/text/qstringbuilder/qstringbuilder4/tst_qstringbuilder4.cpp @@ -16,6 +16,8 @@ #include <QtCore/QStringBuilder> #include <QtTest/QTest> +#include <QtCore/q20iterator.h> + #define LITERAL "some literal" namespace { diff --git a/tests/auto/corelib/text/qstringconverter/tst_qstringconverter.cpp b/tests/auto/corelib/text/qstringconverter/tst_qstringconverter.cpp index ed3f91ac94..342c343a42 100644 --- a/tests/auto/corelib/text/qstringconverter/tst_qstringconverter.cpp +++ b/tests/auto/corelib/text/qstringconverter/tst_qstringconverter.cpp @@ -257,7 +257,7 @@ void tst_QStringConverter::invalidConverter() QVERIFY(!encoder.hasError()); char buffer[100]; char *position = encoder.appendToBuffer(buffer, u"Even more"); - QCOMPARE(position, buffer); + QCOMPARE(position - buffer, 0); QVERIFY(encoder.hasError()); } @@ -283,7 +283,7 @@ void tst_QStringConverter::invalidConverter() QVERIFY(!decoder.hasError()); char16_t buffer[100]; char16_t *position = decoder.appendToBuffer(buffer, "Even more"); - QCOMPARE(position, buffer); + QCOMPARE(position - buffer, 0); QVERIFY(decoder.hasError()); } } diff --git a/tests/auto/corelib/text/qstringview/CMakeLists.txt b/tests/auto/corelib/text/qstringview/CMakeLists.txt index ba5f540838..b541cdd0ed 100644 --- a/tests/auto/corelib/text/qstringview/CMakeLists.txt +++ b/tests/auto/corelib/text/qstringview/CMakeLists.txt @@ -18,5 +18,12 @@ qt_internal_add_test(tst_qstringview Qt::CorePrivate ) +if(QT_FEATURE_sanitize_undefined) + qt_internal_extend_target(tst_qstringview + DEFINES + QT_SANITIZE_UNDEFINED # GCC (in)famously doesn't provide a predefined macro for this + ) +endif() + ## Scopes: ##################################################################### diff --git a/tests/auto/corelib/text/qstringview/tst_qstringview.cpp b/tests/auto/corelib/text/qstringview/tst_qstringview.cpp index df3ef94371..3f87ffc9fc 100644 --- a/tests/auto/corelib/text/qstringview/tst_qstringview.cpp +++ b/tests/auto/corelib/text/qstringview/tst_qstringview.cpp @@ -359,6 +359,30 @@ void tst_QStringView::constExpr() const static_assert(sv3.isEmpty()); static_assert(sv3.size() == 0); } +#if !defined(Q_CC_GNU_ONLY) || !defined(QT_SANITIZE_UNDEFINED) + // Below checks are disabled because of a compilation issue with GCC and + // -fsanitize=undefined. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71962. + { + static constexpr char16_t hello[] = u"Hello"; + constexpr QStringView sv(hello); + static_assert(sv.size() == 5); + static_assert(!sv.empty()); + static_assert(!sv.isEmpty()); + static_assert(!sv.isNull()); + static_assert(*sv.utf16() == 'H'); + static_assert(sv[0] == QLatin1Char('H')); + static_assert(sv.at(0) == QLatin1Char('H')); + static_assert(sv.front() == QLatin1Char('H')); + static_assert(sv.first() == QLatin1Char('H')); + static_assert(sv[4] == QLatin1Char('o')); + static_assert(sv.at(4) == QLatin1Char('o')); + static_assert(sv.back() == QLatin1Char('o')); + static_assert(sv.last() == QLatin1Char('o')); + + constexpr auto sv2 = QStringView::fromArray(hello); + QCOMPARE_EQ(sv, sv2.chopped(1)); + } +#endif // -fsanitize=undefined } void tst_QStringView::basics() const @@ -430,7 +454,7 @@ void tst_QStringView::fromArray() const { static constexpr char16_t hello[] = u"Hello\0abc\0\0."; - constexpr QStringView sv = QStringView::fromArray(hello); + const QStringView sv = QStringView::fromArray(hello); QCOMPARE(sv.size(), 13); QVERIFY(!sv.empty()); QVERIFY(!sv.isEmpty()); diff --git a/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp b/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp index 4cb29c514a..7a8cd707d7 100644 --- a/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp +++ b/tests/auto/corelib/thread/qfuture/tst_qfuture.cpp @@ -3915,7 +3915,7 @@ void tst_QFuture::signalConnect() { SenderObject sender; -#if defined(Q_CC_MSVC_ONLY) && (Q_CC_MSVC < 1940 || __cplusplus < 202002L) +#if defined(Q_CC_MSVC_ONLY) && (Q_CC_MSVC < 1940 || !defined(_DEBUG)) #define EXPECT_FUTURE_CONNECT_FAIL() QEXPECT_FAIL("", "QTBUG-101761, test fails on Windows/MSVC", Continue) #else QTest::ignoreMessage(QtWarningMsg, "QObject::connect: signal not found in SenderObject"); @@ -4632,6 +4632,9 @@ void testWhenAllDifferentTypes() void tst_QFuture::whenAllDifferentTypes() { +#ifdef Q_OS_VXWORKS + QSKIP("std::variant implementation on VxWorks 24.03 is broken and doesn't work with duplicated types"); +#endif using Futures = std::variant<QFuture<int>, QFuture<int>, QFuture<void>>; testWhenAllDifferentTypes<QList<Futures>>(); if (QTest::currentTestFailed()) @@ -4841,6 +4844,9 @@ void tst_QFuture::whenAnyIteratorsWithFailed() void tst_QFuture::whenAnyDifferentTypes() { +#ifdef Q_OS_VXWORKS + QSKIP("std::variant implementation on VxWorks 24.03 is broken and doesn't work with duplicated types"); +#endif QPromise<int> pInt1; QPromise<int> pInt2; QPromise<void> pVoid; diff --git a/tests/auto/corelib/thread/qresultstore/CMakeLists.txt b/tests/auto/corelib/thread/qresultstore/CMakeLists.txt index 0f9d8d9e52..5abfc14ac6 100644 --- a/tests/auto/corelib/thread/qresultstore/CMakeLists.txt +++ b/tests/auto/corelib/thread/qresultstore/CMakeLists.txt @@ -16,4 +16,5 @@ qt_internal_add_test(tst_qresultstore tst_qresultstore.cpp LIBRARIES Qt::CorePrivate + Qt::TestPrivate ) diff --git a/tests/auto/corelib/thread/qresultstore/tst_qresultstore.cpp b/tests/auto/corelib/thread/qresultstore/tst_qresultstore.cpp index 265b2cd1f6..722184a72a 100644 --- a/tests/auto/corelib/thread/qresultstore/tst_qresultstore.cpp +++ b/tests/auto/corelib/thread/qresultstore/tst_qresultstore.cpp @@ -2,7 +2,7 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QTest> - +#include <QtTest/private/qcomparisontesthelper_p.h> #include <qresultstore.h> using namespace QtPrivate; @@ -23,6 +23,7 @@ class tst_QtConcurrentResultStore : public QObject public slots: void init(); private slots: + void compareCompiles(); void construction(); void iterators(); void addResult(); @@ -52,6 +53,11 @@ void tst_QtConcurrentResultStore::init() vec1 = QList<int> { 4, 5 }; } +void tst_QtConcurrentResultStore::compareCompiles() +{ + QTestPrivate::testEqualityOperatorsCompile<ResultIteratorBase>(); +} + void tst_QtConcurrentResultStore::construction() { ResultStoreBase store; @@ -74,17 +80,20 @@ void tst_QtConcurrentResultStore::iterators() storebase.addResult(1, &int1); // ResultStoreBase does not take ownership, only ResultStore<> does. ResultIteratorBase it = storebase.begin(); QCOMPARE(it.resultIndex(), 0); - QCOMPARE(it, storebase.begin()); + QT_TEST_EQUALITY_OPS(it, storebase.begin(), true); QVERIFY(it != storebase.end()); ++it; QCOMPARE(it.resultIndex(), 1); QVERIFY(it != storebase.begin()); QVERIFY(it != storebase.end()); + QT_TEST_EQUALITY_OPS(it, storebase.begin(), false); + QT_TEST_EQUALITY_OPS(it, storebase.end(), false); ++it; QVERIFY(it != storebase.begin()); QCOMPARE(it, storebase.end()); + QT_TEST_EQUALITY_OPS(it, storebase.end(), true); } } @@ -147,8 +156,8 @@ void tst_QtConcurrentResultStore::addResults() store.addResults(-1, &vec1); ResultIteratorBase it = store.begin(); QCOMPARE(it.resultIndex(), 0); - QCOMPARE(it, store.begin()); - QVERIFY(it != store.end()); + QT_TEST_EQUALITY_OPS(it, store.begin(), true); + QT_TEST_EQUALITY_OPS(it, store.end(), false); ++it; QCOMPARE(it.resultIndex(), 1); @@ -162,7 +171,7 @@ void tst_QtConcurrentResultStore::addResults() QCOMPARE(it.resultIndex(), 3); ++it; - QCOMPARE(it, store.end()); + QT_TEST_EQUALITY_OPS(it, store.end(), true); QList<int> empty; const auto countBefore = store.count(); @@ -184,22 +193,22 @@ void tst_QtConcurrentResultStore::resultIndex() ResultIteratorBase it = store.begin(); QCOMPARE(it.resultIndex(), 0); - QVERIFY(it == store.begin()); - QVERIFY(it != store.end()); + QT_TEST_EQUALITY_OPS(it, store.begin(), true); + QT_TEST_EQUALITY_OPS(it, store.end(), false); ++it; QCOMPARE(it.resultIndex(), 1); - QVERIFY(it != store.begin()); - QVERIFY(it != store.end()); + QT_TEST_EQUALITY_OPS(it, store.begin(), false); + QT_TEST_EQUALITY_OPS(it, store.end(), false); ++it; QCOMPARE(it.resultIndex(), 2); - QVERIFY(it != store.end()); + QT_TEST_EQUALITY_OPS(it, store.end(), false); ++it; QCOMPARE(it.resultIndex(), 3); - QVERIFY(it != store.end()); + QT_TEST_EQUALITY_OPS(it, store.end(), false); ++it; - QVERIFY(it == store.end()); + QT_TEST_EQUALITY_OPS(it, store.end(), true); QCOMPARE(store.resultAt(0).value<int>(), int0); QCOMPARE(store.resultAt(1).value<int>(), vec0[0]); diff --git a/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp b/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp index d2e8f63f24..e71f32a3ca 100644 --- a/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp +++ b/tests/auto/corelib/time/qtimezone/tst_qtimezone.cpp @@ -7,6 +7,7 @@ #include <private/qcomparisontesthelper_p.h> #include <qlocale.h> +#include <qscopeguard.h> #if defined(Q_OS_WIN) #include <QOperatingSystemVersion> @@ -16,6 +17,8 @@ # define USING_WIN_TZ #endif +using namespace Qt::StringLiterals; + class tst_QTimeZone : public QObject { Q_OBJECT @@ -38,6 +41,8 @@ private Q_SLOTS: void availableTimeZoneIds(); void utcOffsetId_data(); void utcOffsetId(); + void aliasMatches_data(); + void aliasMatches(); void specificTransition_data(); void specificTransition(); void transitionEachZone_data(); @@ -558,9 +563,12 @@ void tst_QTimeZone::isTimeZoneIdAvailable() const QList<QByteArray> available = QTimeZone::availableTimeZoneIds(); for (const QByteArray &id : available) { QVERIFY2(QTimeZone::isTimeZoneIdAvailable(id), id); - QVERIFY2(QTimeZone(id).isValid(), id); - QCOMPARE(QTimeZone(id).id(), id); + const QTimeZone zone(id); + QVERIFY2(zone.isValid(), id); + QVERIFY2(zone.aliasMatches(id), zone.id() + " != " + id); } + // availableTimeZoneIds() doesn't list all possible offset IDs, but + // isTimeZoneIdAvailable() should accept them. for (qint32 offset = QTimeZone::MinUtcOffsetSecs; offset <= QTimeZone::MinUtcOffsetSecs; ++offset) { const QByteArray id = QTimeZone(offset).id(); @@ -700,6 +708,58 @@ void tst_QTimeZone::utcOffsetId() } } +void tst_QTimeZone::aliasMatches_data() +{ + QTest::addColumn<QByteArray>("iana"); + QTest::addColumn<QByteArray>("alias"); + + QTest::newRow("Montreal=Toronto") << "America/Toronto"_ba << "America/Montreal"_ba; + QTest::newRow("Asmera=Asmara") << "Africa/Asmara"_ba << "Africa/Asmera"_ba; + QTest::newRow("Argentina/Catamarca") + << "America/Argentina/Catamarca"_ba << "America/Catamarca"_ba; + QTest::newRow("Godthab=Nuuk") << "America/Nuuk"_ba << "America/Godthab"_ba; + QTest::newRow("Indiana/Indianapolis") + << "America/Indiana/Indianapolis"_ba << "America/Indianapolis"_ba; + QTest::newRow("Kentucky/Louisville") + << "America/Kentucky/Louisville"_ba << "America/Louisville"_ba; + QTest::newRow("Calcutta=Kolkata") << "Asia/Kolkata"_ba << "Asia/Calcutta"_ba; + QTest::newRow("Katmandu=Kathmandu") << "Asia/Kathmandu"_ba << "Asia/Katmandu"_ba; + QTest::newRow("Rangoon=Yangon") << "Asia/Yangon"_ba << "Asia/Rangoon"_ba; + QTest::newRow("Saigon=Ho_Chi_Minh") << "Asia/Ho_Chi_Minh"_ba << "Asia/Saigon"_ba; + QTest::newRow("Faeroe=Faroe") << "Atlantic/Faroe"_ba << "Atlantic/Faeroe"_ba; + QTest::newRow("Currie=Hobart") << "Australia/Hobart"_ba << "Australia/Currie"_ba; + QTest::newRow("Kiev=Kyiv") << "Europe/Kyiv"_ba << "Europe/Kiev"_ba; + QTest::newRow("Uzhgorod=Kyiv") << "Europe/Kyiv"_ba << "Europe/Uzhgorod"_ba; + QTest::newRow("Zaporozhye=Kyiv") << "Europe/Kyiv"_ba << "Europe/Zaporozhye"_ba; + QTest::newRow("Fiji=Fiji") << "Pacific/Fiji"_ba << "Pacific/Fiji"_ba; + QTest::newRow("Enderbury=Enderbury") << "Pacific/Enderbury"_ba << "Pacific/Enderbury"_ba; +} + +void tst_QTimeZone::aliasMatches() +{ + QFETCH(const QByteArray, iana); + QFETCH(const QByteArray, alias); + const QTimeZone zone(iana); + const QTimeZone peer(alias); + if (!zone.isValid()) + QSKIP("Backend doesn't support IANA ID"); + + auto report = qScopeGuard([zone, peer]() { + const QByteArray zid = zone.id(), pid = peer.id(); + qDebug("Using %s and %s", zid.constData(), pid.constData()); + }); + QVERIFY2(peer.isValid(), "Construction should have fallen back on IANA ID"); + QVERIFY(zone.aliasMatches(zone.id())); + QVERIFY(zone.aliasMatches(iana)); + QVERIFY(peer.aliasMatches(peer.id())); + QVERIFY(peer.aliasMatches(alias)); + QVERIFY(zone.aliasMatches(peer.id())); + QVERIFY(zone.aliasMatches(alias)); + QVERIFY(peer.aliasMatches(zone.id())); + QVERIFY(peer.aliasMatches(iana)); + report.dismiss(); +} + void tst_QTimeZone::specificTransition_data() { QTest::addColumn<QByteArray>("zone"); @@ -924,7 +984,7 @@ void tst_QTimeZone::stressTest() for (const QByteArray &id : idList) { QTimeZone testZone = QTimeZone(id); QCOMPARE(testZone.isValid(), true); - QCOMPARE(testZone.id(), id); + QVERIFY2(testZone.aliasMatches(id), testZone.id() + " != " + id); QDateTime testDate = QDateTime(QDate(2015, 1, 1), QTime(0, 0), UTC); testZone.territory(); testZone.comment(); @@ -972,7 +1032,7 @@ void tst_QTimeZone::windowsId() Current Windows zones for "Central Standard Time": Region IANA Id(s) Default "America/Chicago" - Canada "America/Winnipeg America/Rainy_River America/Rankin_Inlet America/Resolute" + Canada "America/Winnipeg America/Rankin_Inlet America/Resolute" Mexico "America/Matamoros" USA "America/Chicago America/Indiana/Knox America/Indiana/Tell_City America/Menominee" "America/North_Dakota/Beulah America/North_Dakota/Center" @@ -1004,8 +1064,8 @@ void tst_QTimeZone::windowsId() "America/Chicago", "America/Indiana/Knox", "America/Indiana/Tell_City", "America/Matamoros", "America/Menominee", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem", - "America/Ojinaga", "America/Rainy_River", "America/Rankin_Inlet", - "America/Resolute", "America/Winnipeg", "CST6CDT" + "America/Ojinaga", "America/Rankin_Inlet", "America/Resolute", + "America/Winnipeg", "CST6CDT" }; QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time"), list); } @@ -1018,7 +1078,7 @@ void tst_QTimeZone::windowsId() { // Check valid country returns list in preference order const QList<QByteArray> list = { - "America/Winnipeg", "America/Rainy_River", "America/Rankin_Inlet", "America/Resolute" + "America/Winnipeg", "America/Rankin_Inlet", "America/Resolute" }; QCOMPARE(QTimeZone::windowsIdToIanaIds("Central Standard Time", QLocale::Canada), list); } @@ -1280,7 +1340,7 @@ void tst_QTimeZone::utcTest() void tst_QTimeZone::icuTest() { -#if defined(QT_BUILD_INTERNAL) && QT_CONFIG(icu) +#if defined(QT_BUILD_INTERNAL) && QT_CONFIG(icu) && !defined(Q_OS_UNIX) // Known datetimes qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0), QTimeZone::UTC).toMSecsSinceEpoch(); @@ -1323,7 +1383,7 @@ void tst_QTimeZone::icuTest() if (QTest::currentTestFailed()) return; testEpochTranPrivate(QIcuTimeZonePrivate("America/Toronto")); -#endif // icu +#endif // ICU not on Unix } void tst_QTimeZone::tzTest() @@ -1527,7 +1587,7 @@ void tst_QTimeZone::tzTest() QDateTime dt(QDate(2016, 3, 28), QTime(0, 0), UTC); QCOMPARE(tzBarnaul.data(dt.toMSecsSinceEpoch()).abbreviation, QString("+07")); } -#endif // QT_BUILD_INTERNAL && Q_OS_UNIX && !Q_OS_DARWIN +#endif // QT_BUILD_INTERNAL && Q_OS_UNIX && !Q_OS_DARWIN && !Q_OS_ANDROID } void tst_QTimeZone::macTest() @@ -1685,6 +1745,8 @@ void tst_QTimeZone::localeSpecificDisplayName() QVERIFY(zone.isValid()); const QString localeName = zone.displayName(timeType, QTimeZone::LongName, locale); + if (localeName.isEmpty()) // Backend doesn't know how to localize this zone's name + QEXPECT_FAIL("", "QTBUG-115158 zone name localization unknown", Continue); QCOMPARE(localeName, expectedName); } @@ -1857,18 +1919,10 @@ void tst_QTimeZone::stdCompatibility() QFETCH(const std::chrono::time_zone *, timeZone); QByteArrayView zoneName = QByteArrayView(timeZone->name()); QTimeZone tz = QTimeZone::fromStdTimeZonePtr(timeZone); - if (tz.isValid()) { - QCOMPARE(tz.id(), zoneName); - } else { - // QTBUG-102187: a few timezones reported by tzdb might not be - // recognized by QTimeZone. This happens for instance on Windows, where - // tzdb is using ICU, whose database does not match QTimeZone's. - const bool isKnownUnknown = - !zoneName.contains('/') - || zoneName == "Antarctica/Troll" - || zoneName.startsWith("SystemV/"); - QVERIFY(isKnownUnknown); - } + if (tz.isValid()) + QVERIFY2(tz.aliasMatches(zoneName), tz.id().constData()); + else + QVERIFY(!QTimeZone::isTimeZoneIdAvailable(zoneName.toByteArray())); #else QSKIP("This test requires C++20's <chrono>."); #endif diff --git a/tests/auto/corelib/tools/CMakeLists.txt b/tests/auto/corelib/tools/CMakeLists.txt index 5cca2e2df6..5d4d4e9998 100644 --- a/tests/auto/corelib/tools/CMakeLists.txt +++ b/tests/auto/corelib/tools/CMakeLists.txt @@ -47,7 +47,9 @@ add_subdirectory(qset) add_subdirectory(qsharedpointer) add_subdirectory(qsize) add_subdirectory(qsizef) +if (NOT WASM) # QTBUG-121822 add_subdirectory(qspan) +endif() add_subdirectory(qstl) add_subdirectory(quniquehandle) add_subdirectory(qvarlengtharray) diff --git a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp index f52a368aa9..4281d93179 100644 --- a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp +++ b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp @@ -375,6 +375,13 @@ void tst_QBitArray::operator_andeq_data() << QStringToQBitArray(QString()); } +#define COMPARE_BITARRAY_EQ(actual, expected) do { \ + QT_TEST_EQUALITY_OPS(actual, expected, true); \ + QCOMPARE(actual.count(), expected.count()); \ + QCOMPARE(actual.count(true), expected.count(true)); \ + QCOMPARE(actual.count(false), expected.count(false)); \ + } while (false) + void tst_QBitArray::operator_andeq() { QFETCH(QBitArray, input1); @@ -383,32 +390,32 @@ void tst_QBitArray::operator_andeq() QBitArray result = input1; result &= input2; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1; result &= std::move(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1; result &= detached(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is commutative result = input2; result &= input1; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2; result &= std::move(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2; result &= detached(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is idempotent result &= result; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result &= std::move(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result &= detached(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); } void tst_QBitArray::operator_and() @@ -418,27 +425,27 @@ void tst_QBitArray::operator_and() QFETCH(QBitArray, res); QBitArray result = input1 & input2; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1 & QBitArray(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1 & detached(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is commutative result = input2 & input1; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2 & QBitArray(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2 & detached(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is idempotent result = result & result; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = result & QBitArray(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = result & detached(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); } void tst_QBitArray::operator_oreq_data() @@ -489,32 +496,32 @@ void tst_QBitArray::operator_oreq() QBitArray result = input1; result |= input2; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1; result |= QBitArray(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1; result |= detached(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is commutative result = input2; result |= input1; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2; result |= QBitArray(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2; result |= detached(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is idempotent result |= result; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result |= QBitArray(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result |= detached(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); } void tst_QBitArray::operator_or() @@ -524,27 +531,27 @@ void tst_QBitArray::operator_or() QFETCH(QBitArray, res); QBitArray result = input1 | input2; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1 | QBitArray(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1 | detached(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is commutative result = input2 | input1; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2 | QBitArray(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2 | detached(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is idempotent result = result | result; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = result | QBitArray(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = result | detached(result); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); } void tst_QBitArray::operator_xoreq_data() @@ -593,24 +600,24 @@ void tst_QBitArray::operator_xoreq() QBitArray result = input1; result ^= input2; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1; result ^= QBitArray(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1; result ^= detached(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is commutative result = input2; result ^= input1; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2; result ^= QBitArray(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2; result ^= detached(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // XORing with oneself is nilpotent result = input1; @@ -651,19 +658,19 @@ void tst_QBitArray::operator_xor() QFETCH(QBitArray, res); QBitArray result = input1 ^ input2; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1 ^ QBitArray(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input1 ^ detached(input2); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // operation is commutative result = input2 ^ input1; - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2 ^ QBitArray(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); result = input2 ^ detached(input1); - QT_TEST_EQUALITY_OPS(result, res, true); + COMPARE_BITARRAY_EQ(result, res); // XORing with oneself is nilpotent result = input1 ^ input1; @@ -734,7 +741,7 @@ void tst_QBitArray::operator_neg() input = ~input; - QT_TEST_EQUALITY_OPS(input, res, true); + COMPARE_BITARRAY_EQ(input, res); QT_TEST_EQUALITY_OPS(~~input, res, true); // performs two in-place negations } @@ -795,9 +802,9 @@ void tst_QBitArray::datastream() QCOMPARE(array1.count(true), onBits); QCOMPARE(array1.count(false), numBits - onBits); - QT_TEST_EQUALITY_OPS(array1, bits, true); - QT_TEST_EQUALITY_OPS(array2, bits, true); - QT_TEST_EQUALITY_OPS(array3, bits, true); + COMPARE_BITARRAY_EQ(array1, bits); + COMPARE_BITARRAY_EQ(array2, bits); + COMPARE_BITARRAY_EQ(array3, bits); } void tst_QBitArray::invertOnNull() const diff --git a/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp b/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp index c08afd67c4..47e0ead270 100644 --- a/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp +++ b/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp @@ -20,6 +20,8 @@ private slots: void repeated_result(); void intermediary_result_data(); void intermediary_result(); + void static_hash_data() { intermediary_result_data(); } + void static_hash(); void sha1(); void sha3_data(); void sha3(); @@ -29,9 +31,9 @@ private slots: void blake2(); void files_data(); void files(); - void hashLength_data(); + void hashLength_data() { all_methods(true); } void hashLength(); - void addDataAcceptsNullByteArrayView_data() { hashLength_data(); } + void addDataAcceptsNullByteArrayView_data() { all_methods(false); } void addDataAcceptsNullByteArrayView(); void move(); void swap(); @@ -40,6 +42,7 @@ private slots: void moreThan4GiBOfData(); void keccakBufferOverflow(); private: + void all_methods(bool includingNumAlgorithms) const; void ensureLargeData(); std::vector<char> large; }; @@ -197,6 +200,20 @@ void tst_QCryptographicHash::intermediary_result() hash.reset(); } +void tst_QCryptographicHash::static_hash() +{ + QFETCH(const int, algo); + QFETCH(const QByteArray, first); + QFETCH(const QByteArray, hash_first); + + const auto _algo = QCryptographicHash::Algorithm(algo); + + QCOMPARE(QCryptographicHash::hash(first, _algo), hash_first); + + std::byte buffer[1024]; + QCOMPARE(QCryptographicHash::hashInto(buffer, first, _algo), hash_first); +} + void tst_QCryptographicHash::sha1() { @@ -474,12 +491,14 @@ void tst_QCryptographicHash::files() } } -void tst_QCryptographicHash::hashLength_data() +void tst_QCryptographicHash::all_methods(bool inclNumAlgos) const { QTest::addColumn<QCryptographicHash::Algorithm>("algorithm"); auto metaEnum = QMetaEnum::fromType<QCryptographicHash::Algorithm>(); for (int i = 0, value = metaEnum.value(i); value != -1; value = metaEnum.value(++i)) { auto algorithm = QCryptographicHash::Algorithm(value); + if (!inclNumAlgos && algorithm == QCryptographicHash::Algorithm::NumAlgorithms) + continue; QTest::addRow("%s", metaEnum.key(i)) << algorithm; } } @@ -495,6 +514,9 @@ void tst_QCryptographicHash::hashLength() expectedSize = 0; } else { expectedSize = QCryptographicHash::hash("test", algorithm).size(); + + std::byte buffer[1024]; + QCOMPARE(QCryptographicHash::hashInto(buffer, "foo", algorithm).size(), expectedSize); } QCOMPARE(QCryptographicHash::hashLength(algorithm), expectedSize); } diff --git a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp index f42637a3fe..772b3f827f 100644 --- a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp +++ b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp @@ -59,6 +59,7 @@ private slots: void objectCastStdSharedPtr(); void differentPointers(); void virtualBaseDifferentPointers(); + void virtualBaseWeakPointerConversions(); #ifndef QTEST_NO_RTTI void dynamicCast(); void dynamicCastDifferentPointers(); @@ -1294,6 +1295,67 @@ void tst_QSharedPointer::virtualBaseDifferentPointers() safetyCheck(); } +void tst_QSharedPointer::virtualBaseWeakPointerConversions() +{ + struct Base { virtual ~Base() = default; }; + struct Derived : virtual Base {}; + + { + QSharedPointer<Derived> d(new Derived); + QSharedPointer<const Base> cb = d; + QCOMPARE(cb, d); + QCOMPARE(cb.get(), d.get()); + } + safetyCheck(); + + { + QSharedPointer<Derived> d(new Derived); + QWeakPointer<const Base> wcb = d; + QCOMPARE(wcb, d); + QCOMPARE(wcb.lock().get(), d.get()); + } + safetyCheck(); + + { + QSharedPointer<Derived> d(new Derived); + QWeakPointer<Derived> wd = d; + QCOMPARE(wd, d); + QCOMPARE(wd.lock().get(), d.get()); + QWeakPointer<const Base> wcb = wd; + QCOMPARE(wcb, wd); + QCOMPARE(wcb.lock().get(), d.get()); + } + safetyCheck(); + + { + auto raw = new Derived; + QSharedPointer<Derived> d(raw); + QSharedPointer<const Base> cb = std::move(d); + QCOMPARE(d, nullptr); + QCOMPARE(cb.get(), raw); + } + safetyCheck(); + + { + QSharedPointer<Derived> d(new Derived); + QWeakPointer<const Base> wcb = std::move(d); + QCOMPARE(wcb, d); + QCOMPARE(wcb.lock().get(), d.get()); + } + safetyCheck(); + + { + QSharedPointer<Derived> d(new Derived); + QWeakPointer<Derived> wd = std::move(d); + QCOMPARE(wd, d); + QCOMPARE(wd.lock().get(), d.get()); + QWeakPointer<const Base> wcb = std::move(wd); + QCOMPARE(wd, nullptr); + QCOMPARE(wcb.lock().get(), d.get()); + } + safetyCheck(); +} + #ifndef QTEST_NO_RTTI void tst_QSharedPointer::dynamicCast() { diff --git a/tests/auto/corelib/tools/qsize/CMakeLists.txt b/tests/auto/corelib/tools/qsize/CMakeLists.txt index 91de696ddd..4a4c96b52c 100644 --- a/tests/auto/corelib/tools/qsize/CMakeLists.txt +++ b/tests/auto/corelib/tools/qsize/CMakeLists.txt @@ -14,4 +14,6 @@ endif() qt_internal_add_test(tst_qsize SOURCES tst_qsize.cpp + LIBRARIES + Qt::TestPrivate ) diff --git a/tests/auto/corelib/tools/qsize/tst_qsize.cpp b/tests/auto/corelib/tools/qsize/tst_qsize.cpp index c9699c5e76..d379275dd8 100644 --- a/tests/auto/corelib/tools/qsize/tst_qsize.cpp +++ b/tests/auto/corelib/tools/qsize/tst_qsize.cpp @@ -24,6 +24,7 @@ CHECK(const &&); #undef CHECK #include <QTest> +#include <QtTest/private/qcomparisontesthelper_p.h> #include <qsize.h> #include <array> @@ -34,6 +35,10 @@ class tst_QSize : public QObject { Q_OBJECT private slots: + void compareCompiles(); + void compare_data(); + void compare(); + void getSetCheck(); void scale(); @@ -55,6 +60,38 @@ private slots: void structuredBinding(); }; +void tst_QSize::compareCompiles() +{ + QTestPrivate::testEqualityOperatorsCompile<QSize>(); +} + +void tst_QSize::compare_data() +{ + QTest::addColumn<QSize>("lhs"); + QTest::addColumn<QSize>("rhs"); + QTest::addColumn<bool>("result"); + + auto row = [](QSize lhs, QSize rhs, bool res) { + QTest::addRow("(%d, %d) vs (%d, %d)", lhs.width(), lhs.height(), rhs.width(), rhs.height()) + << lhs << rhs << res; + }; + + row(QSize(0, 0), QSize(0, 0), true); + row(QSize(1, 0), QSize(0, 1), false); + row(QSize(-1, -1), QSize(-1, -1), true); + row(QSize(-1, -1), QSize(1, 1), false); + row(QSize(INT_MIN, INT_MAX), QSize(INT_MAX, INT_MIN), false); +} + +void tst_QSize::compare() +{ + QFETCH(QSize, lhs); + QFETCH(QSize, rhs); + QFETCH(bool, result); + + QT_TEST_EQUALITY_OPS(lhs, rhs, result); +} + // Testing get/set functions void tst_QSize::getSetCheck() { diff --git a/tests/auto/corelib/tools/qsizef/CMakeLists.txt b/tests/auto/corelib/tools/qsizef/CMakeLists.txt index 9adaafe2ea..d8a1c7f46e 100644 --- a/tests/auto/corelib/tools/qsizef/CMakeLists.txt +++ b/tests/auto/corelib/tools/qsizef/CMakeLists.txt @@ -14,4 +14,6 @@ endif() qt_internal_add_test(tst_qsizef SOURCES tst_qsizef.cpp + LIBRARIES + Qt::TestPrivate ) diff --git a/tests/auto/corelib/tools/qsizef/tst_qsizef.cpp b/tests/auto/corelib/tools/qsizef/tst_qsizef.cpp index ee33fa13b6..bb087e89de 100644 --- a/tests/auto/corelib/tools/qsizef/tst_qsizef.cpp +++ b/tests/auto/corelib/tools/qsizef/tst_qsizef.cpp @@ -24,17 +24,30 @@ CHECK(const &&); #undef CHECK #include <QTest> +#include <QtTest/private/qcomparisontesthelper_p.h> #include <qsize.h> Q_DECLARE_METATYPE(QMarginsF) +static constexpr qreal qreal_min = std::numeric_limits<qreal>::min(); + class tst_QSizeF : public QObject { Q_OBJECT private slots: + void compareCompiles(); + void compare_data(); + void compare(); + + void fuzzyCompare_data(); + void fuzzyCompare(); + void isNull_data(); void isNull(); + void fuzzyIsNull_data(); + void fuzzyIsNull(); + void scale(); void expandedTo(); @@ -52,6 +65,61 @@ private slots: void structuredBinding(); }; +void tst_QSizeF::compareCompiles() +{ + QTestPrivate::testEqualityOperatorsCompile<QSizeF>(); + QTestPrivate::testEqualityOperatorsCompile<QSizeF, QSize>(); +} + +void tst_QSizeF::compare_data() +{ + QTest::addColumn<QSizeF>("lhs"); + QTest::addColumn<QSizeF>("rhs"); + QTest::addColumn<bool>("result"); + QTest::addColumn<bool>("mixedResult"); + + auto row = [&](QSizeF lhs, QSizeF rhs, bool res, bool mixedRes) { + QString str; + QDebug dbg(&str); + dbg.nospace() << "(" << lhs.width() << ", " << lhs.height() << ") vs " + << "(" << rhs.width() << ", " << rhs.height() << ")"; + QTest::addRow("%s", str.toLatin1().constData()) << lhs << rhs << res << mixedRes; + }; + + row(QSizeF(0.0, 0.0), QSizeF(0.0, 0.0), true, true); + row(QSizeF(1.0, 2.0), QSizeF(1.0, 2.0), true, true); + row(QSizeF(1.0, -1.0), QSizeF(-1.0, 1.0), false, false); + row(QSizeF(0.1, 1.1), QSizeF(0.1, 1.1), true, false); + row(QSizeF(qreal_min, 0.0), QSizeF(0.0, -qreal_min), true, true); +} + +void tst_QSizeF::compare() +{ + QFETCH(QSizeF, lhs); + QFETCH(QSizeF, rhs); + QFETCH(bool, result); + QFETCH(bool, mixedResult); + + QT_TEST_EQUALITY_OPS(lhs, rhs, result); + + const QSize rhsFixed = rhs.toSize(); + QT_TEST_EQUALITY_OPS(lhs, rhsFixed, mixedResult); +} + +void tst_QSizeF::fuzzyCompare_data() +{ + compare_data(); +} + +void tst_QSizeF::fuzzyCompare() +{ + QFETCH(QSizeF, lhs); + QFETCH(QSizeF, rhs); + QFETCH(bool, result); + + QCOMPARE_EQ(qFuzzyCompare(lhs, rhs), result); +} + void tst_QSizeF::isNull_data() { QTest::addColumn<qreal>("width"); @@ -66,6 +134,7 @@ void tst_QSizeF::isNull_data() QTest::newRow("0, -0.1") << qreal(0) << qreal(-0.1) << false; QTest::newRow("0.1, 0") << qreal(0.1) << qreal(0) << false; QTest::newRow("0, 0.1") << qreal(0) << qreal(0.1) << false; + QTest::newRow("qreal_min, -qreal_min") << qreal_min << -qreal_min << false; } void tst_QSizeF::isNull() @@ -80,6 +149,33 @@ void tst_QSizeF::isNull() QCOMPARE(size.isNull(), isNull); } +void tst_QSizeF::fuzzyIsNull_data() +{ + QTest::addColumn<qreal>("width"); + QTest::addColumn<qreal>("height"); + QTest::addColumn<bool>("fuzzyNull"); + + QTest::newRow("0, 0") << qreal(0.0) << qreal(0.0) << true; + QTest::newRow("-0, -0") << qreal(-0.0) << qreal(-0.0) << true; + QTest::newRow("0, -0") << qreal(0) << qreal(-0.0) << true; + QTest::newRow("-0, 0") << qreal(-0.0) << qreal(0) << true; + QTest::newRow("-0.1, 0") << qreal(-0.1) << qreal(0) << false; + QTest::newRow("0, -0.1") << qreal(0) << qreal(-0.1) << false; + QTest::newRow("0.1, 0") << qreal(0.1) << qreal(0) << false; + QTest::newRow("0, 0.1") << qreal(0) << qreal(0.1) << false; + QTest::newRow("qreal_min, -qreal_min") << qreal_min << -qreal_min << true; +} + +void tst_QSizeF::fuzzyIsNull() +{ + QFETCH(qreal, width); + QFETCH(qreal, height); + QFETCH(bool, fuzzyNull); + + QSizeF size(width, height); + QCOMPARE(qFuzzyIsNull(size), fuzzyNull); +} + void tst_QSizeF::scale() { QSizeF t1(10.4, 12.8); t1.scale(60.6, 60.6, Qt::IgnoreAspectRatio); diff --git a/tests/auto/corelib/tools/qspan/CMakeLists.txt b/tests/auto/corelib/tools/qspan/CMakeLists.txt index 595d19dc43..b4517640a0 100644 --- a/tests/auto/corelib/tools/qspan/CMakeLists.txt +++ b/tests/auto/corelib/tools/qspan/CMakeLists.txt @@ -10,4 +10,8 @@ endif() qt_internal_add_test(tst_qspan SOURCES tst_qspan.cpp + NO_BATCH # QTBUG-121815 + DEFINES + QTEST_THROW_ON_FAIL + QTEST_THROW_ON_SKIP ) diff --git a/tests/auto/corelib/tools/qspan/tst_qspan.cpp b/tests/auto/corelib/tools/qspan/tst_qspan.cpp index 91d2ecf739..95c60ee953 100644 --- a/tests/auto/corelib/tools/qspan/tst_qspan.cpp +++ b/tests/auto/corelib/tools/qspan/tst_qspan.cpp @@ -6,6 +6,10 @@ #include <QList> #include <QTest> +#ifndef QTEST_THROW_ON_FAIL +# error This test requires QTEST_THROW_ON_FAIL being active. +#endif + #include <algorithm> #include <array> #ifdef __cpp_lib_span @@ -141,31 +145,27 @@ private: void from_variable_size_container_impl(C &&c) const; }; -#define RETURN_IF_FAILED() \ - do { if (QTest::currentTestFailed()) return; } while (false) +template <typename T> +const void *as_const_void(T *p) noexcept { return static_cast<const void *>(p); } void tst_QSpan::onlyZeroExtentSpansHaveDefaultCtors() const { static_assert(std::is_nothrow_default_constructible_v<QSpan<int, 0>>); static_assert(std::is_nothrow_default_constructible_v<QSpan<const int, 0>>); static_assert(std::is_nothrow_default_constructible_v<QSpan<int>>); - static_assert(std::is_nothrow_default_constructible_v<QSpan<const int, 0>>); + static_assert(std::is_nothrow_default_constructible_v<QSpan<const int>>); QSpan<int, 0> si; check_null_span(si); - RETURN_IF_FAILED(); QSpan<const int, 0> sci; check_null_span(sci); - RETURN_IF_FAILED(); QSpan<int> sdi; check_null_span(sdi); - RETURN_IF_FAILED(); QSpan<const int> sdci; check_null_span(sdci); - RETURN_IF_FAILED(); static_assert(!std::is_default_constructible_v<QSpan<int, 1>>); static_assert(!std::is_default_constructible_v<QSpan<const int, 42>>); @@ -173,26 +173,22 @@ void tst_QSpan::onlyZeroExtentSpansHaveDefaultCtors() const void tst_QSpan::zeroExtentSpansMaintainADataPointer() const { - int i; + int i = 0; QSpan<int, 0> si{&i, 0}; QCOMPARE(si.data(), &i); check_empty_span_incl_subspans(si); - RETURN_IF_FAILED(); QSpan<const int, 0> sci{&i, 0}; QCOMPARE(sci.data(), &i); check_empty_span_incl_subspans(sci); - RETURN_IF_FAILED(); QSpan<int, 0> sdi{&i, 0}; QCOMPARE(sdi.data(), &i); check_empty_span_incl_subspans(sdi); - RETURN_IF_FAILED(); QSpan<const int, 0> sdci{&i, 0}; QCOMPARE(sdci.data(), &i); check_empty_span_incl_subspans(sdci); - RETURN_IF_FAILED(); } template <typename T, std::size_t N> @@ -230,18 +226,14 @@ void tst_QSpan::check_nonempty_span(QSpan<T, N> s, qsizetype expectedSize) const // don't run into Mandates: Offset >= Extent if constexpr (N > 0) { // incl. N == std::dynamic_extent check_empty_span_incl_subspans(s.template subspan<1>()); - RETURN_IF_FAILED(); } check_empty_span_incl_subspans(s.subspan(1)); - RETURN_IF_FAILED(); } else { // don't run into Mandates: Offset >= Extent if constexpr (N > 1) { // incl. N == std::dynamic_extent check_nonempty_span(s.template subspan<1>(), expectedSize - 1); - RETURN_IF_FAILED(); } check_nonempty_span(s.subspan(1), expectedSize - 1); - RETURN_IF_FAILED(); } } @@ -263,55 +255,46 @@ template <typename T, std::size_t N> void tst_QSpan::check_empty_span_incl_subspans(QSpan<T, N> s) const { check_empty_span(s); - RETURN_IF_FAILED(); { const auto fi = s.template first<0>(); check_empty_span(fi); - RETURN_IF_FAILED(); QCOMPARE_EQ(fi.data(), s.data()); } { const auto la = s.template last<0>(); check_empty_span(la); - RETURN_IF_FAILED(); QCOMPARE_EQ(la.data(), s.data()); } { const auto ss = s.template subspan<0>(); check_empty_span(ss); - RETURN_IF_FAILED(); QCOMPARE_EQ(ss.data(), s.data()); } { const auto ss = s.template subspan<0, 0>(); check_empty_span(ss); - RETURN_IF_FAILED(); QCOMPARE_EQ(ss.data(), s.data()); } { const auto fi = s.first(0); check_empty_span(fi); - RETURN_IF_FAILED(); QCOMPARE_EQ(fi.data(), s.data()); } { const auto la = s.last(0); check_empty_span(la); - RETURN_IF_FAILED(); QCOMPARE_EQ(la.data(), s.data()); } { const auto ss = s.subspan(0); check_empty_span(ss); - RETURN_IF_FAILED(); QCOMPARE_EQ(ss.data(), s.data()); } { const auto ss = s.subspan(0, 0); check_empty_span(ss); - RETURN_IF_FAILED(); QCOMPARE_EQ(ss.data(), s.data()); } } @@ -334,6 +317,8 @@ void tst_QSpan::from_container_impl(C &&c) const const auto c_data = QSpanPrivate::adl_data(c); using V = std::remove_reference_t<QSpanPrivate::range_reference_t<C>>; + constexpr auto ExpectedBytesExtent + = ExpectedExtent == q20::dynamic_extent ? q20::dynamic_extent : ExpectedExtent * sizeof(V); { QSpan si = c; // CTAD static_assert(std::is_same_v<decltype(si), QSpan<V, ExpectedExtent>>); @@ -342,7 +327,20 @@ void tst_QSpan::from_container_impl(C &&c) const QCOMPARE_EQ(si.data(), c_data); check_nonempty_span(si, c_size); - RETURN_IF_FAILED(); + + auto bi = as_bytes(si); + static_assert(std::is_same_v<decltype(bi), QSpan<const std::byte, ExpectedBytesExtent>>); + QCOMPARE_EQ(bi.size(), si.size_bytes()); + QCOMPARE_EQ(as_const_void(bi.data()), + as_const_void(si.data())); + + if constexpr (!std::is_const_v<V>) { // e.g. std::initializer_list<int> + auto wbi = as_writable_bytes(si); + static_assert(std::is_same_v<decltype(wbi), QSpan<std::byte, ExpectedBytesExtent>>); + QCOMPARE_EQ(wbi.size(), si.size_bytes()); + QCOMPARE_EQ(as_const_void(wbi.data()), + as_const_void(si.data())); + } QSpan<const int> sci = c; @@ -350,7 +348,12 @@ void tst_QSpan::from_container_impl(C &&c) const QCOMPARE_EQ(sci.data(), c_data); check_nonempty_span(sci, c_size); - RETURN_IF_FAILED(); + + auto bci = as_bytes(sci); + static_assert(std::is_same_v<decltype(bci), QSpan<const std::byte>>); + QCOMPARE_EQ(bci.size(), sci.size_bytes()); + QCOMPARE_EQ(as_const_void(bci.data()), + as_const_void(sci.data())); } { QSpan sci = std::as_const(c); // CTAD @@ -360,7 +363,12 @@ void tst_QSpan::from_container_impl(C &&c) const QCOMPARE_EQ(sci.data(), c_data); check_nonempty_span(sci, c_size); - RETURN_IF_FAILED(); + + auto bci = as_bytes(sci); + static_assert(std::is_same_v<decltype(bci), QSpan<const std::byte, ExpectedBytesExtent>>); + QCOMPARE_EQ(bci.size(), sci.size_bytes()); + QCOMPARE_EQ(as_const_void(bci.data()), + as_const_void(sci.data())); } } @@ -395,7 +403,6 @@ void tst_QSpan::fromStdInitializerList() const QCOMPARE_EQ(sci.data(), il.begin()); check_nonempty_span(sci, 4); - RETURN_IF_FAILED(); } void tst_QSpan::fromZeroSizeStdArray() const @@ -444,7 +451,5 @@ void tst_QSpan::fromInitList() const l2({4, 5, 6}); } -#undef RETURN_IF_FAILED - QTEST_APPLESS_MAIN(tst_QSpan); #include "tst_qspan.moc" |