diff options
Diffstat (limited to 'tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp')
-rw-r--r-- | tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp | 254 |
1 files changed, 254 insertions, 0 deletions
diff --git a/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp b/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp new file mode 100644 index 0000000000..4c4ff72722 --- /dev/null +++ b/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp @@ -0,0 +1,254 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QTest> +#include <qoperatingsystemversion.h> + +class tst_QOperatingSystemVersion : public QObject +{ + Q_OBJECT +private slots: + void construction_data(); + void construction(); + void globals_data(); + void globals(); + + void anyOf(); + + void comparison_data(); + void comparison(); + void comparison2_data(); + void comparison2(); + + void mixedComparison(); +}; + +void tst_QOperatingSystemVersion::construction_data() +{ + QTest::addColumn<QOperatingSystemVersion::OSType>("osType"); + QTest::addColumn<int>("majorVersion"); + QTest::addColumn<int>("minorVersion"); + QTest::addColumn<int>("microVersion"); + QTest::addColumn<int>("segmentCount"); + + QTest::newRow("Major only") << QOperatingSystemVersion::OSType::Windows << 1 << -1 << -1 << 1; + QTest::newRow("Major and minor") << QOperatingSystemVersion::OSType::MacOS + << 1 << 2 << -1 << 2; + QTest::newRow("Major, minor and micro") << QOperatingSystemVersion::OSType::Android + << 1 << 2 << 3 << 3; +} + +void tst_QOperatingSystemVersion::construction() +{ + QFETCH(QOperatingSystemVersion::OSType, osType); + QFETCH(int, majorVersion); + QFETCH(int, minorVersion); + QFETCH(int, microVersion); + QFETCH(int, segmentCount); + + const QOperatingSystemVersion systemVersion(osType, majorVersion, minorVersion, microVersion); + QCOMPARE(systemVersion.type(), osType); + QCOMPARE(systemVersion.segmentCount(), segmentCount); + QCOMPARE(systemVersion.majorVersion(), majorVersion); + QCOMPARE(systemVersion.minorVersion(), minorVersion); + QCOMPARE(systemVersion.microVersion(), microVersion); + if (osType != QOperatingSystemVersion::OSType::Unknown) + QVERIFY(!systemVersion.name().isEmpty()); +} + +void tst_QOperatingSystemVersion::globals_data() +{ + QTest::addColumn<QOperatingSystemVersion>("osver"); + QTest::addColumn<QOperatingSystemVersion::OSType>("osType"); + +#define ADDROW(os) QTest::newRow(#os) << QOperatingSystemVersion(QOperatingSystemVersion::os) + // legacy ones (global variables) + ADDROW(Windows7) << QOperatingSystemVersion::Windows; + ADDROW(Windows10) << QOperatingSystemVersion::Windows; + ADDROW(OSXMavericks) << QOperatingSystemVersion::MacOS; + ADDROW(MacOSMonterey) << QOperatingSystemVersion::MacOS; + ADDROW(AndroidJellyBean) << QOperatingSystemVersion::Android; + ADDROW(Android11) << QOperatingSystemVersion::Android; + + // new ones (static constexpr) + ADDROW(Windows11) << QOperatingSystemVersion::Windows; + ADDROW(Android12) << QOperatingSystemVersion::Android; +#undef ADDROW +} + +void tst_QOperatingSystemVersion::globals() +{ + QFETCH(QOperatingSystemVersion, osver); + QFETCH(QOperatingSystemVersion::OSType, osType); + QCOMPARE(osver.type(), osType); + QCOMPARE_NE(osver.majorVersion(), 0); +} + +void tst_QOperatingSystemVersion::anyOf() +{ + std::initializer_list<QOperatingSystemVersion::OSType> typesToCheck = { + QOperatingSystemVersion::OSType::Windows, QOperatingSystemVersion::OSType::Android, + QOperatingSystemVersion::OSType::MacOS, QOperatingSystemVersion::OSType::Unknown + }; + { + // type found case + const QOperatingSystemVersion systemVersion(QOperatingSystemVersion::OSType::MacOS, 1); + QCOMPARE(systemVersion.isAnyOfType(typesToCheck), true); + } + { + // type NOT found case + const QOperatingSystemVersion systemVersion(QOperatingSystemVersion::OSType::WatchOS, 1); + QCOMPARE(systemVersion.isAnyOfType(typesToCheck), false); + } +} + +void tst_QOperatingSystemVersion::comparison_data() +{ + QTest::addColumn<QOperatingSystemVersion::OSType>("lhsType"); + QTest::addColumn<int>("lhsMajor"); + QTest::addColumn<int>("lhsMinor"); + QTest::addColumn<int>("lhsMicro"); + + QTest::addColumn<QOperatingSystemVersion::OSType>("rhsType"); + QTest::addColumn<int>("rhsMajor"); + QTest::addColumn<int>("rhsMinor"); + QTest::addColumn<int>("rhsMicro"); + + QTest::addColumn<Qt::partial_ordering>("expectedResult"); + + QTest::addRow("mismatching types") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << QOperatingSystemVersion::OSType::MacOS << 1 << 2 << 3 + << Qt::partial_ordering::unordered; + + QTest::addRow("equal versions") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << Qt::partial_ordering::equivalent; + + QTest::addRow("lhs micro less") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 2 + << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << Qt::partial_ordering::less; + + QTest::addRow("rhs micro less") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 2 + << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 1 + << Qt::partial_ordering::greater; + + QTest::addRow("lhs minor less") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << QOperatingSystemVersion::OSType::Windows << 1 << 3 << 3 + << Qt::partial_ordering::less; + + QTest::addRow("rhs minor less") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 2 + << QOperatingSystemVersion::OSType::Windows << 1 << 1 << 3 + << Qt::partial_ordering::greater; + + QTest::addRow("lhs major less") << QOperatingSystemVersion::OSType::Windows << 0 << 5 << 6 + << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << Qt::partial_ordering::less; + + QTest::addRow("rhs major less") << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << QOperatingSystemVersion::OSType::Windows << 0 << 2 << 3 + << Qt::partial_ordering::greater; + + QTest::addRow("different segmentCount") + << QOperatingSystemVersion::OSType::Windows << 1 << 2 << 3 + << QOperatingSystemVersion::OSType::Windows << 1 << 2 << -1 + << Qt::partial_ordering::equivalent; +} + +void tst_QOperatingSystemVersion::comparison() +{ + QFETCH(QOperatingSystemVersion::OSType, lhsType); + QFETCH(int, lhsMajor); + QFETCH(int, lhsMinor); + QFETCH(int, lhsMicro); + + const QOperatingSystemVersion lhsSystemInfo(lhsType, lhsMajor, lhsMinor, lhsMicro); + + QFETCH(QOperatingSystemVersion::OSType, rhsType); + QFETCH(int, rhsMajor); + QFETCH(int, rhsMinor); + QFETCH(int, rhsMicro); + + const QOperatingSystemVersion rhsSystemInfo(rhsType, rhsMajor, rhsMinor, rhsMicro); + + QFETCH(const Qt::partial_ordering, expectedResult); + + QCOMPARE_EQ(lhsSystemInfo < rhsSystemInfo, is_lt(expectedResult)); + QCOMPARE_EQ(lhsSystemInfo <= rhsSystemInfo, is_lteq(expectedResult)); + QCOMPARE_EQ(lhsSystemInfo > rhsSystemInfo, is_gt(expectedResult)); + QCOMPARE_EQ(lhsSystemInfo >= rhsSystemInfo, is_gteq(expectedResult)); +#ifdef __cpp_lib_three_way_comparison + QCOMPARE_EQ(lhsSystemInfo <=> rhsSystemInfo, expectedResult); +#endif +} + +void tst_QOperatingSystemVersion::comparison2_data() +{ + QTest::addColumn<QOperatingSystemVersion>("lhs"); + QTest::addColumn<QOperatingSystemVersion>("rhs"); + QTest::addColumn<Qt::partial_ordering>("result"); + +#define ADDROW(os1, os2) \ + QTest::newRow(#os1 "-vs-" #os2) << QOperatingSystemVersion(QOperatingSystemVersion::os1) \ + << QOperatingSystemVersion(QOperatingSystemVersion::os2) + + // Cross-OS testing: not comparables. + ADDROW(Windows10, MacOSMonterey) << Qt::partial_ordering::unordered; + ADDROW(Windows11, MacOSMonterey) << Qt::partial_ordering::unordered; + ADDROW(MacOSMonterey, Windows10) << Qt::partial_ordering::unordered; + ADDROW(MacOSMonterey, Windows11) << Qt::partial_ordering::unordered; + ADDROW(Windows10, MacOSVentura) << Qt::partial_ordering::unordered; + ADDROW(Windows11, MacOSVentura) << Qt::partial_ordering::unordered; + ADDROW(MacOSVentura, Windows10) << Qt::partial_ordering::unordered; + ADDROW(MacOSVentura, Windows11) << Qt::partial_ordering::unordered; + ADDROW(Windows10, Android10) << Qt::partial_ordering::unordered; + ADDROW(Windows11, Android11) << Qt::partial_ordering::unordered; + + // Same-OS tests. This list does not have to be exhaustive. + ADDROW(Windows7, Windows7) << Qt::partial_ordering::equivalent; + ADDROW(Windows7, Windows8) << Qt::partial_ordering::less; + ADDROW(Windows8, Windows7) << Qt::partial_ordering::greater; + ADDROW(Windows8, Windows10) << Qt::partial_ordering::less; + ADDROW(Windows10, Windows8) << Qt::partial_ordering::greater; + ADDROW(Windows10, Windows10_21H1) << Qt::partial_ordering::less; + ADDROW(Windows10_21H1, Windows10) << Qt::partial_ordering::greater; + ADDROW(Windows10, Windows11) << Qt::partial_ordering::less; + ADDROW(MacOSCatalina, MacOSCatalina) << Qt::partial_ordering::equivalent; + ADDROW(MacOSCatalina, MacOSBigSur) << Qt::partial_ordering::less; + ADDROW(MacOSBigSur, MacOSCatalina) << Qt::partial_ordering::greater; + ADDROW(MacOSMonterey, MacOSVentura) << Qt::partial_ordering::less; + ADDROW(MacOSVentura, MacOSVentura) << Qt::partial_ordering::equivalent; + ADDROW(MacOSVentura, MacOSMonterey) << Qt::partial_ordering::greater; +#undef ADDROW +} + +void tst_QOperatingSystemVersion::comparison2() +{ + QFETCH(QOperatingSystemVersion, lhs); + QFETCH(QOperatingSystemVersion, rhs); + QFETCH(const Qt::partial_ordering, result); + + QEXPECT_FAIL("Windows10-vs-Windows10_21H1", "QTBUG-107907: Unexpected behavior", Abort); + QEXPECT_FAIL("Windows10-vs-Windows11", "QTBUG-107907: Unexpected behavior", Abort); + + const bool comparable = (result != Qt::partial_ordering::unordered); + QCOMPARE_EQ(lhs < rhs, is_lt(result) && comparable); + QEXPECT_FAIL("Windows10_21H1-vs-Windows10", "QTBUG-107907: Unexpected behavior", Abort); + QCOMPARE_EQ(lhs <= rhs, is_lteq(result) && comparable); + QCOMPARE_EQ(lhs > rhs, is_gt(result) && comparable); + QCOMPARE_EQ(lhs >= rhs, is_gteq(result) && comparable); +#ifdef __cpp_lib_three_way_comparison + QCOMPARE_EQ(lhs <=> rhs, result); +#endif +} + +void tst_QOperatingSystemVersion::mixedComparison() +{ + // == + QVERIFY(QOperatingSystemVersion::Windows10 + >= QOperatingSystemVersionBase(QOperatingSystemVersionBase::Windows, 10, 0)); + QVERIFY(QOperatingSystemVersion::Windows10 + <= QOperatingSystemVersionBase(QOperatingSystemVersionBase::Windows, 10, 0)); +} + +QTEST_MAIN(tst_QOperatingSystemVersion) +#include "tst_qoperatingsystemversion.moc" |