diff options
Diffstat (limited to 'tests/auto/qml/qmltyperegistrar/tst_qmltyperegistrar.h')
| -rw-r--r-- | tests/auto/qml/qmltyperegistrar/tst_qmltyperegistrar.h | 363 |
1 files changed, 349 insertions, 14 deletions
diff --git a/tests/auto/qml/qmltyperegistrar/tst_qmltyperegistrar.h b/tests/auto/qml/qmltyperegistrar/tst_qmltyperegistrar.h index df755472d7..efb40fd426 100644 --- a/tests/auto/qml/qmltyperegistrar/tst_qmltyperegistrar.h +++ b/tests/auto/qml/qmltyperegistrar/tst_qmltyperegistrar.h @@ -1,46 +1,49 @@ // Copyright (C) 2020 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #ifndef TST_QMLTYPEREGISTRAR_H #define TST_QMLTYPEREGISTRAR_H #include "foreign.h" -#include "foreign_p.h" +#include "private/foreign_p.h" -#include <QtQml/qqml.h> -#include <QtQml/qqmlcomponent.h> -#include <QtCore/qproperty.h> -#include <QtCore/qtimeline.h> -#include <QtCore/qrect.h> #include <QtQmlTypeRegistrar/private/qqmltyperegistrar_p.h> -#include <QtCore/qtemporaryfile.h> #ifdef QT_QUICK_LIB # include <QtQuick/qquickitem.h> #endif -class Interface {}; +#include <QtQml/qqml.h> +#include <QtQml/qqmlcomponent.h> + +#include <QtCore/qabstractitemmodel.h> +#include <QtCore/qproperty.h> +#include <QtCore/qrect.h> +#include <QtCore/qtemporaryfile.h> +#include <QtCore/qtimeline.h> + +class Interface1 {}; class Interface2 {}; class Interface3 {}; QT_BEGIN_NAMESPACE -Q_DECLARE_INTERFACE(Interface, "io.qt.bugreports.Interface"); +Q_DECLARE_INTERFACE(Interface1, "io.qt.bugreports.Interface1"); Q_DECLARE_INTERFACE(Interface2, "io.qt.bugreports.Interface2"); Q_DECLARE_INTERFACE(Interface3, "io.qt.bugreports.Interface3"); QT_END_NAMESPACE -class ImplementsInterfaces : public QObject, public Interface +class ImplementsInterfaces : public QObject, public Interface1 { Q_OBJECT QML_ELEMENT - QML_IMPLEMENTS_INTERFACES(Interface) + QML_IMPLEMENTS_INTERFACES(Interface1) }; -class ImplementsInterfaces2 : public QObject, public Interface, public Interface2 +class ImplementsInterfaces2 : public QObject, public Interface1, public Interface2 { Q_OBJECT QML_ELEMENT - QML_IMPLEMENTS_INTERFACES(Interface Interface2) + QML_IMPLEMENTS_INTERFACES(Interface1 Interface2) }; class ExcessiveVersion : public QObject @@ -458,6 +461,29 @@ public: int revisioned() const { return 24; } }; +class AddedInLateMinorVersion : public QObject +{ + Q_OBJECT + QML_ADDED_IN_VERSION(1, 5) + Q_PROPERTY(int revisioned READ revisioned CONSTANT) + QML_NAMED_ELEMENT(MinorVersioned) +public: + AddedInLateMinorVersion(QObject *parent = nullptr) : QObject(parent) {} + int revisioned() const { return 123; } +}; + +class RemovedInLateMinorVersion : public QObject +{ + Q_OBJECT + QML_ADDED_IN_VERSION(1, 2) + QML_REMOVED_IN_VERSION(1, 4) + Q_PROPERTY(int revisioned READ revisioned CONSTANT) + QML_NAMED_ELEMENT(MinorVersioned) +public: + RemovedInLateMinorVersion(QObject *parent = nullptr) : QObject(parent) { } + int revisioned() const { return 456; } +}; + class RemovedInEarlyVersion : public AddedInLateVersion { Q_OBJECT @@ -468,6 +494,23 @@ public: RemovedInEarlyVersion(QObject *parent = nullptr) : AddedInLateVersion(parent) {} }; +class AddedIn1_5 : public QObject +{ + Q_OBJECT + QML_ELEMENT + QML_ADDED_IN_VERSION(1, 5) +}; + +// Slightly absurd. The reason for such a thing may be a change in the versioning +// scheme of the base class. We still have to retain all of the version information +// so that you can at least use version 1.5. +class AddedIn1_0 : public AddedIn1_5 +{ + Q_OBJECT + QML_ELEMENT + QML_ADDED_IN_VERSION(1, 0) +}; + class HasResettableProperty : public QObject { Q_OBJECT @@ -501,6 +544,272 @@ signals: void clonedSignal(int i = 7); }; +class Unconstructible +{ + Q_GADGET + QML_VALUE_TYPE(unconstructible) + int m_i = 11; +}; + +class Constructible +{ + Q_GADGET + QML_VALUE_TYPE(constructible) + QML_CONSTRUCTIBLE_VALUE +public: + Q_INVOKABLE Constructible(int i = 12) : m_i(i) {} + +private: + int m_i; +}; + +class Structured +{ + Q_GADGET + QML_VALUE_TYPE(structured) + QML_STRUCTURED_VALUE + Q_PROPERTY(int i MEMBER m_i FINAL) + +private: + int m_i; +}; + +class AnonymousAndUncreatable : public QObject +{ + Q_OBJECT + QML_ANONYMOUS + QML_UNCREATABLE("Pointless uncreatable message") +}; + +class Invisible : public QObject +{ +}; + +struct InvisibleForeign +{ + Q_GADGET + QML_FOREIGN(Invisible) + QML_NAMED_ELEMENT(Invisible) +}; + +class TypedEnum : public QObject +{ + Q_OBJECT + QML_ELEMENT +public: + enum UChar: uchar { V0 = 41 }; + Q_ENUM(UChar) + enum Int8_T: int8_t { V1 = 42 }; + Q_ENUM(Int8_T) + enum UInt8_T: uint8_t { V2 = 43 }; + Q_ENUM(UInt8_T) + enum Int16_T: int16_t { V3 = 44 }; + Q_ENUM(Int16_T) + enum UInt16_T: uint16_t { V4 = 45 }; + Q_ENUM(UInt16_T) + enum Int32_T: int32_t { V5 = 46 }; + Q_ENUM(Int32_T) + enum UInt32_T: uint32_t { V6 = 47 }; + Q_ENUM(UInt32_T) + + // TODO: We cannot handle 64bit numbers as underlying types for enums. + // Luckily, moc generates bad code for those. So we don't have to, for now. + + enum S: qint16 { + A, B, C + }; + Q_ENUM(S) + + enum T: quint16 { + D, E, F + }; + Q_ENUM(T) + + enum U: qint8 { + G, H, I + }; + Q_ENUM(U) + + enum V: quint8 { + J, K, L + }; + Q_ENUM(V) +}; + +class ListSignal : public QObject +{ + Q_OBJECT + QML_ANONYMOUS + +Q_SIGNALS: + void objectListHappened(const QList<QObject *> &); +}; + +class Bar : public QObject +{ + Q_OBJECT + Q_PROPERTY(int outerBarProp READ bar CONSTANT) +public: + Bar(QObject *parent = nullptr) : QObject(parent) {} + int bar() const { return 44; } +}; + +namespace Testing { + +class Foo : public QObject +{ + Q_OBJECT + Q_PROPERTY(int fooProp READ foo CONSTANT) + +public: + int foo() const { return 42; } +}; + +class Bar : public Foo +{ + Q_OBJECT + QML_ELEMENT + Q_PROPERTY(int barProp READ bar CONSTANT) + +public: + int bar() const { return 43; } +}; + +namespace Inner { + +class Baz : public Bar +{ + Q_OBJECT + QML_ELEMENT + + QML_EXTENDED(::Bar) + QML_ATTACHED(Foo) + +public: + static Foo *qmlAttachedProperties(QObject *) { return new Foo; } +}; + +} // namespace Inner +} // namespace Testing + +struct QByteArrayStdVectorForeign +{ + Q_GADGET + QML_ANONYMOUS + QML_SEQUENTIAL_CONTAINER(QByteArray) + QML_FOREIGN(std::vector<QByteArray>) +}; + +// Anonymous value type for an unknown foreign type +struct QPersistentModelIndexValueType +{ + QPersistentModelIndex v; + Q_PROPERTY(int row READ row FINAL) + Q_GADGET + QML_ANONYMOUS + QML_EXTENDED(QPersistentModelIndexValueType) + QML_FOREIGN(QPersistentModelIndex) + +public: + inline int row() const { return v.row(); } +}; + + +namespace NetworkManager { +Q_NAMESPACE + +enum NM { A, B, C}; +Q_ENUM_NS(NM) +} + +struct NMForeign +{ + Q_GADGET + QML_NAMED_ELEMENT(NetworkManager) + QML_FOREIGN_NAMESPACE(NetworkManager) +}; + +struct NotNamespace { + Q_GADGET +public: + enum Abc { + A, B, C, D + }; + Q_ENUM(Abc); +}; + +struct NotNamespaceForeign { + Q_GADGET + QML_FOREIGN_NAMESPACE(NotNamespace) + QML_ELEMENT +}; + +class NameExplosion : public QObject +{ + Q_OBJECT + QML_NAMED_ELEMENT(Name1) + QML_NAMED_ELEMENT(Name2) + QML_ELEMENT + QML_ANONYMOUS +}; + +class JavaScriptExtension : public QObject +{ + Q_OBJECT + QML_ELEMENT + Q_CLASSINFO("QML.Extended", "SymbolPrototype") + Q_CLASSINFO("QML.ExtensionIsJavaScript", "true") +}; + +class LongNumberTypes : public QObject +{ + Q_OBJECT + QML_ELEMENT + Q_PROPERTY(qint64 a MEMBER m_a) + Q_PROPERTY(int64_t b MEMBER m_b) + Q_PROPERTY(quint64 c MEMBER m_c) + Q_PROPERTY(uint64_t d MEMBER m_d) + + qint64 m_a = 1; + int64_t m_b = 2; + quint64 m_c = 3; + uint64_t m_d = 4; +}; + +struct EnumList +{ + Q_GADGET + QML_ANONYMOUS + QML_FOREIGN(QList<NetworkManager::NM>) + QML_SEQUENTIAL_CONTAINER(NetworkManager::NM) +}; + +class ConstInvokable : public QObject +{ + Q_OBJECT + QML_ELEMENT +public: + Q_INVOKABLE const QObject *getObject() { return nullptr; } +}; + +using myint = int; + +struct IntAlias +{ + Q_GADGET + QML_FOREIGN(myint) + QML_USING(int); +}; + +class WithMyInt : public QObject +{ + Q_OBJECT + QML_ELEMENT + Q_PROPERTY(myint a READ a CONSTANT) +public: + myint a() const { return 10; } +}; + class tst_qmltyperegistrar : public QObject { Q_OBJECT @@ -537,6 +846,7 @@ private slots: void methodReturnType(); void hasIsConstantInParameters(); void uncreatable(); + void singletonVersions(); #ifdef QT_QUICK_LIB void foreignRevisionedProperty(); @@ -544,11 +854,36 @@ private slots: void addRemoveVersion_data(); void addRemoveVersion(); + void addInMinorVersion(); void typeInModuleMajorVersionZero(); void resettableProperty(); void duplicateExportWarnings(); void clonedSignal(); void baseVersionInQmltypes(); + void unconstructibleValueType(); + void constructibleValueType(); + void structuredValueType(); + void anonymousAndUncreatable(); + void omitInvisible(); + void typedEnum(); + void listSignal(); + void withNamespace(); + void sequenceRegistration(); + void valueTypeSelfReference(); + void foreignNamespaceFromGadget(); + + void nameExplosion_data(); + void nameExplosion(); + + void javaScriptExtension(); + + void consistencyWarnings(); + void relatedAddedInVersion(); + void longNumberTypes(); + void enumList(); + void constReturnType(); + + void usingDeclaration(); private: QByteArray qmltypesData; |