diff options
Diffstat (limited to 'tests/auto/corelib/kernel/qmetaproperty')
-rw-r--r-- | tests/auto/corelib/kernel/qmetaproperty/CMakeLists.txt | 8 | ||||
-rw-r--r-- | tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp | 152 |
2 files changed, 155 insertions, 5 deletions
diff --git a/tests/auto/corelib/kernel/qmetaproperty/CMakeLists.txt b/tests/auto/corelib/kernel/qmetaproperty/CMakeLists.txt index 9762ea2642..49c07afd87 100644 --- a/tests/auto/corelib/kernel/qmetaproperty/CMakeLists.txt +++ b/tests/auto/corelib/kernel/qmetaproperty/CMakeLists.txt @@ -1,12 +1,16 @@ # Copyright (C) 2022 The Qt Company Ltd. # SPDX-License-Identifier: BSD-3-Clause -# Generated from qmetaproperty.pro. - ##################################################################### ## tst_qmetaproperty Test: ##################################################################### +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qmetaproperty LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + qt_internal_add_test(tst_qmetaproperty SOURCES tst_qmetaproperty.cpp diff --git a/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp b/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp index f459068bef..3bf6211a53 100644 --- a/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp +++ b/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp @@ -1,6 +1,6 @@ // Copyright (C) 2016 The Qt Company Ltd. // Copyright (C) 2015 Olivier Goffart <ogoffart@woboq.com> -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QTest> @@ -22,7 +22,14 @@ struct CustomType Q_DECLARE_METATYPE(CustomType) -class tst_QMetaProperty : public QObject +class Base : public QObject +{ + Q_OBJECT +signals: + void baseSignal(int); +}; + +class tst_QMetaProperty : public Base { Q_OBJECT Q_PROPERTY(EnumType value WRITE setValue READ getValue) @@ -33,6 +40,7 @@ class tst_QMetaProperty : public QObject Q_PROPERTY(int value10 READ value10 FINAL) Q_PROPERTY(QMap<int, int> map MEMBER map) Q_PROPERTY(CustomType custom MEMBER custom) + Q_PROPERTY(int propWithInheritedSig READ propWithInheritedSig NOTIFY baseSignal) private slots: void hasStdCppSet(); @@ -43,6 +51,7 @@ private slots: void mapProperty(); void conversion(); void enumsFlags(); + void notifySignalIndex(); public: enum EnumType { EnumType1 }; @@ -57,6 +66,8 @@ public: int value9() const { return 1; } int value10() const { return 1; } + int propWithInheritedSig() const { return 0; } + QString value7; QMap<int, int> map; CustomType custom; @@ -159,11 +170,55 @@ public: {} }; +enum FreeEnum { + FreeEnumValue1, + FreeEnumValue2 +}; + +namespace MySpace { + enum NamespacedEnum { + NamespacedEnumValue1, + NamespacedEnumValue2 + }; +}; + +namespace MyQtSpace { + Q_NAMESPACE + enum NamespacedEnum { + NamespacedEnumValue1, + NamespacedEnumValue2 + }; + Q_DECLARE_FLAGS(NamespacedFlags, NamespacedEnum) + Q_FLAG_NS(NamespacedFlags) +}; + +namespace SeparateEnumNamespace { + Q_NAMESPACE + enum Enum { + Value1, + Value2 + }; + Q_ENUM_NS(Enum) +}; +namespace SeparateFlagsNamespace { + Q_NAMESPACE + Q_DECLARE_FLAGS(Flags, SeparateEnumNamespace::Enum) + Q_FLAG_NS(Flags) +} + class EnumFlagsTester : public QObject { Q_OBJECT Q_PROPERTY(TestEnum enumProperty READ enumProperty WRITE setEnumProperty) Q_PROPERTY(TestFlags flagProperty READ flagProperty WRITE setFlagProperty) + + Q_PROPERTY(FreeEnum freeEnumProperty READ freeEnumProperty WRITE setFreeEnumProperty) + Q_PROPERTY(MySpace::NamespacedEnum namespacedEnumProperty READ namespacedEnumProperty WRITE setNamespacedEnumProperty) + Q_PROPERTY(MyQtSpace::NamespacedEnum qtNamespacedEnumProperty READ qtNamespacedEnumProperty WRITE setQtNamespacedEnumProperty) + Q_PROPERTY(MyQtSpace::NamespacedFlags qtNamespacedFlagProperty READ qtNamespacedFlagProperty WRITE setQtNamespacedFlagProperty) + + Q_PROPERTY(SeparateEnumNamespace::Enum sepEnum READ sepEnum WRITE setSepEnum) + Q_PROPERTY(SeparateFlagsNamespace::Flags sepFlags READ sepFlags WRITE setSepFlags) public: enum TestEnum { e1, e2 }; Q_ENUM(TestEnum) @@ -179,9 +234,35 @@ public: TestFlags flagProperty() const { return m_flags; } void setFlagProperty(TestFlags f) { m_flags = f; } + FreeEnum freeEnumProperty() const { return m_freeEnum; } + void setFreeEnumProperty(FreeEnum e) { m_freeEnum = e; } + + MySpace::NamespacedEnum namespacedEnumProperty() const { return m_namespacedEnum; } + void setNamespacedEnumProperty(MySpace::NamespacedEnum e) { m_namespacedEnum = e; } + + MyQtSpace::NamespacedEnum qtNamespacedEnumProperty() const { return m_qtNamespaceEnum; } + void setQtNamespacedEnumProperty(MyQtSpace::NamespacedEnum e) { m_qtNamespaceEnum = e; } + + MyQtSpace::NamespacedFlags qtNamespacedFlagProperty() const { return m_qtNamespaceFlags; } + void setQtNamespacedFlagProperty(MyQtSpace::NamespacedFlags f) { m_qtNamespaceFlags = f; } + + SeparateEnumNamespace::Enum sepEnum() const { return m_sepEnum; } + void setSepEnum(SeparateEnumNamespace::Enum e) { m_sepEnum = e; } + + SeparateFlagsNamespace::Flags sepFlags() const { return m_sepFlags; } + void setSepFlags(SeparateFlagsNamespace::Flags f) { m_sepFlags = f; } + private: TestEnum m_enum = e1; TestFlags m_flags; + + FreeEnum m_freeEnum = FreeEnum::FreeEnumValue1; + MySpace::NamespacedEnum m_namespacedEnum = MySpace::NamespacedEnumValue1; + MyQtSpace::NamespacedEnum m_qtNamespaceEnum = MyQtSpace::NamespacedEnumValue1; + MyQtSpace::NamespacedFlags m_qtNamespaceFlags; + + SeparateEnumNamespace::Enum m_sepEnum = SeparateEnumNamespace::Value1; + SeparateFlagsNamespace::Flags m_sepFlags; }; Q_DECLARE_OPERATORS_FOR_FLAGS(EnumFlagsTester::TestFlags) @@ -254,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(); @@ -265,6 +346,7 @@ void tst_QMetaProperty::enumsFlags() QVERIFY(enumProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); QVERIFY(enumProperty.write(&t, QVariant(int(EnumFlagsTester::e2)))); QCOMPARE(t.enumProperty(), EnumFlagsTester::e2); + QVERIFY(enumProperty.enumerator().isValid()); // OK: Q_ENUM const int flagsIndex = mo->indexOfProperty("flagProperty"); QVERIFY(flagsIndex >= 0); @@ -272,6 +354,70 @@ void tst_QMetaProperty::enumsFlags() QVERIFY(flagsProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); QVERIFY(flagsProperty.write(&t, QVariant(int(EnumFlagsTester::flag2)))); QCOMPARE(t.flagProperty(), EnumFlagsTester::flag2); + QVERIFY(!flagsProperty.enumerator().isValid()); // Not using Q_FLAG + + const int freeEnumIndex = mo->indexOfProperty("freeEnumProperty"); + QVERIFY(freeEnumIndex >= 0); + auto freeEnumProperty = mo->property(freeEnumIndex); + QVERIFY(freeEnumProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); + QVERIFY(freeEnumProperty.write(&t, QVariant(FreeEnumValue2))); + QCOMPARE(t.freeEnumProperty(), FreeEnumValue2); + QVERIFY(!freeEnumProperty.enumerator().isValid()); // Not using Q_ENUM + + const int namespacedEnumIndex = mo->indexOfProperty("namespacedEnumProperty"); + QVERIFY(namespacedEnumIndex >= 0); + auto namespacedEnumProperty = mo->property(namespacedEnumIndex); + QVERIFY(namespacedEnumProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); + QVERIFY(namespacedEnumProperty.write(&t, QVariant(MySpace::NamespacedEnumValue2))); + QCOMPARE(t.namespacedEnumProperty(), MySpace::NamespacedEnumValue2); + QVERIFY(!namespacedEnumProperty.enumerator().isValid()); // Not using Q_NAMESPACE/Q_ENUM_NS + + const int qtNamespacedEnumIndex = mo->indexOfProperty("qtNamespacedEnumProperty"); + QVERIFY(qtNamespacedEnumIndex >= 0); + auto qtNamespacedEnumProperty = mo->property(qtNamespacedEnumIndex); + QVERIFY(qtNamespacedEnumProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); + QVERIFY(qtNamespacedEnumProperty.write(&t, QVariant(MyQtSpace::NamespacedEnumValue2))); + QCOMPARE(t.qtNamespacedEnumProperty(), MyQtSpace::NamespacedEnumValue2); + QVERIFY(qtNamespacedEnumProperty.enumerator().isValid()); // OK: Q_ENUM_NS + + const int qtNamespacedFlagIndex = mo->indexOfProperty("qtNamespacedFlagProperty"); + QVERIFY(qtNamespacedFlagIndex >= 0); + auto qtNamespacedFlagProperty = mo->property(qtNamespacedFlagIndex); + QVERIFY(qtNamespacedFlagProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); + QVERIFY(qtNamespacedFlagProperty.write(&t, QVariant(MyQtSpace::NamespacedFlags(MyQtSpace::NamespacedEnumValue2)))); + QCOMPARE(t.qtNamespacedFlagProperty(), MyQtSpace::NamespacedFlags(MyQtSpace::NamespacedEnumValue2)); + QVERIFY(qtNamespacedFlagProperty.enumerator().isValid()); // OK: Q_FLAG + + const int sepEnumIndex = mo->indexOfProperty("sepEnum"); + QVERIFY(sepEnumIndex >= 0); + auto sepEnumProperty = mo->property(sepEnumIndex); + QVERIFY(sepEnumProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); + QVERIFY(sepEnumProperty.write(&t, QVariant(SeparateEnumNamespace::Value2))); + QCOMPARE(t.sepEnum(), SeparateEnumNamespace::Value2); + QVERIFY(sepEnumProperty.enumerator().isValid()); // OK: Q_ENUM_NS + + const int sepFlagsIndex = mo->indexOfProperty("sepFlags"); + QVERIFY(sepFlagsIndex >= 0); + auto sepFlagsProperty = mo->property(sepFlagsIndex); + QVERIFY(sepFlagsProperty.metaType().flags().testFlag(QMetaType::IsEnumeration)); + QVERIFY(sepFlagsProperty.write(&t, QVariant(SeparateEnumNamespace::Value1))); + QCOMPARE(t.sepFlags(), SeparateEnumNamespace::Value1); + QVERIFY(!sepFlagsProperty.enumerator().isValid()); // NOK: the meta object is empty +} + + +void tst_QMetaProperty::notifySignalIndex() +{ + auto mo = this->metaObject(); + auto propIndex = mo->indexOfProperty("propWithInheritedSig"); + auto propWithInheritedSig = mo->property(propIndex); + QVERIFY(propWithInheritedSig.isValid()); + QVERIFY(propWithInheritedSig.hasNotifySignal()); + QVERIFY(propWithInheritedSig.notifySignalIndex() != -1); + QMetaMethod notifySignal = propWithInheritedSig.notifySignal(); + QVERIFY(notifySignal.isValid()); + QCOMPARE(notifySignal.name(), "baseSignal"); + QCOMPARE(notifySignal.parameterCount(), 1); } QTEST_MAIN(tst_QMetaProperty) |