qt 6.5.1 original

tests/auto/corelib/global/qkeycombination/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## tst_qkeycombination Test:
+#####################################################################
+
+qt_internal_add_test(tst_qkeycombination
+    SOURCES
+        tst_qkeycombination.cpp
+)

tests/auto/corelib/global/qkeycombination/tst_qkeycombination.cpp

@@ -0,0 +1,292 @@
+// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QObject>
+#include <QTest>
+
+class tst_QKeyCombination : public QObject
+{
+    Q_OBJECT
+private slots:
+    void construction();
+    void operator_eq();
+    void operator_or();
+};
+
+constexpr int bitwiseOr()
+{
+    return 0;
+}
+
+template <typename ...T>
+constexpr auto bitwiseOr(T ... args)
+{
+    return (... | ((int)args));
+}
+
+void tst_QKeyCombination::construction()
+{
+    {
+        QKeyCombination combination;
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers{});
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::Key_unknown));
+    }
+
+    {
+        QKeyCombination combination(Qt::CTRL); // explicit
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::ControlModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::ControlModifier, Qt::Key_unknown));
+    }
+
+    {
+        QKeyCombination combination(Qt::SHIFT); // explicit
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::ShiftModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::ShiftModifier, Qt::Key_unknown));
+    }
+
+    {
+        QKeyCombination combination(Qt::AltModifier); // explicit
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::AltModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::AltModifier, Qt::Key_unknown));
+    }
+
+    {
+        QKeyCombination combination(Qt::AltModifier | Qt::ControlModifier); // explicit
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::AltModifier | Qt::ControlModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::AltModifier, Qt::ControlModifier, Qt::Key_unknown));
+    }
+
+    {
+        QKeyCombination combination = Qt::Key_A; // implicit
+        QCOMPARE(combination.key(), Qt::Key_A);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers{});
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::Key_A));
+    }
+
+    {
+        QKeyCombination combination = Qt::Key_F1; // implicit
+        QCOMPARE(combination.key(), Qt::Key_F1);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers{});
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::Key_F1));
+    }
+
+    {
+        QKeyCombination combination(Qt::SHIFT, Qt::Key_F1);
+        QCOMPARE(combination.key(), Qt::Key_F1);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::ShiftModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::SHIFT, Qt::Key_F1));
+    }
+
+    {
+        QKeyCombination combination(Qt::SHIFT | Qt::CTRL, Qt::Key_F1);
+        QCOMPARE(combination.key(), Qt::Key_F1);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::ShiftModifier | Qt::ControlModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::SHIFT, Qt::CTRL, Qt::Key_F1));
+    }
+
+    {
+        QKeyCombination combination(Qt::AltModifier, Qt::Key_F1);
+        QCOMPARE(combination.key(), Qt::Key_F1);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::AltModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::AltModifier, Qt::Key_F1));
+    }
+
+    // corner cases
+    {
+        QKeyCombination combination = Qt::Key_Alt;
+        QCOMPARE(combination.key(), Qt::Key_Alt);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers{});
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::Key_Alt));
+    }
+
+    {
+        QKeyCombination combination(Qt::ALT, Qt::Key_Alt);
+        QCOMPARE(combination.key(), Qt::Key_Alt);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::AltModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::ALT, Qt::Key_Alt));
+    }
+
+    {
+        QKeyCombination combination(Qt::Key_unknown);
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers{});
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::Key_unknown));
+    }
+
+    {
+        QKeyCombination combination(Qt::CTRL | Qt::SHIFT, Qt::Key_unknown);
+        QCOMPARE(combination.key(), Qt::Key_unknown);
+        QCOMPARE(combination.keyboardModifiers(), Qt::KeyboardModifiers(Qt::ControlModifier | Qt::ShiftModifier));
+        QCOMPARE(combination.toCombined(), bitwiseOr(Qt::CTRL, Qt::SHIFT, Qt::Key_unknown));
+    }
+}
+
+void tst_QKeyCombination::operator_eq()
+{
+    // default
+    {
+        QKeyCombination a, b;
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    // key only
+    {
+        QKeyCombination a;
+        QKeyCombination b(Qt::Key_X);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::Key_Y);
+        QKeyCombination b;
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::Key_Y);
+        QKeyCombination b(Qt::Key_X);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::Key_F1);
+        QKeyCombination b(Qt::Key_F1);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    // modifier only
+    {
+        QKeyCombination a;
+        QKeyCombination b(Qt::CTRL);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::CTRL);
+        QKeyCombination b;
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::CTRL);
+        QKeyCombination b(Qt::SHIFT);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::CTRL);
+        QKeyCombination b(Qt::CTRL);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QKeyCombination a(Qt::CTRL);
+        QKeyCombination b(Qt::ControlModifier);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QKeyCombination a(Qt::ControlModifier);
+        QKeyCombination b(Qt::CTRL);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QKeyCombination a(Qt::ControlModifier);
+        QKeyCombination b(Qt::ControlModifier);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    // key and modifier
+    {
+        QKeyCombination a(Qt::Key_A);
+        QKeyCombination b(Qt::SHIFT, Qt::Key_A);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::CTRL, Qt::Key_A);
+        QKeyCombination b(Qt::SHIFT, Qt::Key_A);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::SHIFT, Qt::Key_A);
+        QKeyCombination b(Qt::SHIFT, Qt::Key_A);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QKeyCombination a(Qt::SHIFT, Qt::Key_A);
+        QKeyCombination b(Qt::SHIFT, Qt::Key_Escape);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::SHIFT, Qt::Key_A);
+        QKeyCombination b(Qt::ShiftModifier, Qt::Key_A);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    {
+        QKeyCombination a(Qt::SHIFT | Qt::CTRL, Qt::Key_A);
+        QKeyCombination b(Qt::ControlModifier | Qt::ShiftModifier, Qt::Key_A);
+        QVERIFY(a == b);
+        QVERIFY(!(a != b));
+    }
+
+    // corner cases
+    {
+        QKeyCombination a(Qt::CTRL);
+        QKeyCombination b(Qt::Key_Control);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+
+    {
+        QKeyCombination a(Qt::ALT);
+        QKeyCombination b(Qt::Key_Alt);
+        QVERIFY(a != b);
+        QVERIFY(!(a == b));
+    }
+}
+
+void tst_QKeyCombination::operator_or()
+{
+    // note tha operator+ between enumerators of the same enumeration
+    // yields int, so one can't do
+    //    Qt::SHIFT + Qt::CTRL + Qt::Key_A
+    // but one can do
+    //    Qt::SHIFT | Qt::CTRL | Qt::Key_A
+
+    QCOMPARE(Qt::SHIFT | Qt::Key_A, QKeyCombination(Qt::SHIFT, Qt::Key_A));
+    QCOMPARE(Qt::AltModifier | Qt::Key_F1, QKeyCombination(Qt::AltModifier, Qt::Key_F1));
+    QCOMPARE(Qt::SHIFT | Qt::ALT | Qt::Key_F1, QKeyCombination(Qt::SHIFT | Qt::ALT, Qt::Key_F1));
+    QCOMPARE(Qt::ControlModifier | Qt::Key_Escape, QKeyCombination(Qt::ControlModifier, Qt::Key_Escape));
+}
+
+QTEST_APPLESS_MAIN(tst_QKeyCombination)
+
+#include "tst_qkeycombination.moc"