qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/tests/auto/qml/qqmljsscope/tst_qqmljsscope.cpp

281 lines
9.6 KiB
C++
Raw Normal View History

Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <QtQuickTestUtils/private/qmlutils_p.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qdir.h>
#include <QtCore/qdiriterator.h>
#include <QtCore/qurl.h>
#include <QtCore/qlibraryinfo.h>
#include <QtQml/qqmlengine.h>
#include <QtQml/qqmlcomponent.h>
#include <QtQml/private/qqmlirbuilder_p.h>
#include <private/qqmljscompiler_p.h>
#include <private/qqmljsscope_p.h>
#include <private/qqmljsimporter_p.h>
#include <private/qqmljslogger_p.h>
#include <private/qqmljsimportvisitor_p.h>
#include <private/qqmljstyperesolver_p.h>
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
#include <QtQml/private/qqmljslexer_p.h>
#include <QtQml/private/qqmljsparser_p.h>
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
class tst_qqmljsscope : public QQmlDataTest
{
Q_OBJECT
QString loadUrl(const QString &url)
{
const QFileInfo fi(url);
QFile f(fi.absoluteFilePath());
f.open(QIODevice::ReadOnly);
QByteArray data(fi.size(), Qt::Uninitialized);
f.read(data.data(), data.length());
return QString::fromUtf8(data);
}
QQmlJSScope::ConstPtr run(QString url)
{
url = testFile(url);
const QString sourceCode = loadUrl(url);
if (sourceCode.isEmpty())
return QQmlJSScope::ConstPtr();
QmlIR::Document document(false);
// NB: JS unit generated here is ignored, so use noop function
QQmlJSSaveFunction noop([](auto &&...) { return true; });
QQmlJSCompileError error;
[&]() {
QVERIFY2(qCompileQmlFile(document, url, noop, nullptr, &error),
qPrintable(error.message));
}();
if (!error.message.isEmpty())
return QQmlJSScope::ConstPtr();
Add a default implementation for QQmlJSAotCompiler The default AOT compiler compiles QML code in indirect, dynamic mode. It uses the logger's Log_Compiler category to determine the verbosity of its output. In addition you can use the qt.qml.compiler.aot category for even more verbosity. In preparation for using QQmlJSAotCompiler with qmlcachegen, the default level of that category is increased to QtFatalMsg. The highest level we actually output is QtDebugMsg, so it doesn't make a difference yet. If the logger's Log_Compiler category is set to produce errors, it will qFatal() on "pragma Strict" violations. Change-Id: Ieb74bfa7cd51cfa8616792ab467c32f6ba0e0702 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-18 13:26:29 +00:00
QQmlJSLogger logger;
logger.setFileName(url);
logger.setCode(sourceCode);
logger.setSilent(true);
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
QQmlJSImportVisitor visitor(&m_importer, &logger, dataDirectory());
QQmlJSTypeResolver typeResolver { &m_importer };
qmllint: Re-enable warning about automatched signal handler ... and give a hint on what to do about it. In order to not duplicate all the warnings from the importer, make sure it runs only once. Change-Id: Ie2b314ff659664f7c84c20cc7971c094e15c59cf Reviewed-by: Maximilian Goldstein <max.goldstein@qt.io>
2021-11-23 15:05:05 +00:00
typeResolver.init(&visitor, document.program);
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
return visitor.result();
}
private Q_SLOTS:
void initTestCase() override;
void orderedBindings();
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
void signalCreationDifferences();
QmlCompiler: Discern between internal and anonymous imports Anonymous imports are imports of QML types that aren't visible in the current document. Internal imports are imports of C++ types, also invisible, but potentially of the same names. Before, types with exports were added to the qmltypes container using their exports if any matched. If there were no exports, we constructed a synthetic name and inserted that. However, as the nullptr example shows, we need a reliable way to find them by their internal names, no matter if exports are present. Therefore, we now consistently add them by their internal names using the new $internal$ prefix. Change-Id: I42ac2447cd924d09970c24554e1e2a5e631c5f79 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-03 13:39:58 +00:00
void allTypesAvailable();
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
void shadowing();
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#ifdef LABS_QML_MODELS_PRESENT
void componentWrappedObjects();
Add QmlModels dependency to LabsQmlModels Some classes (e.g. QQmlDelegateChooser) depend-on / inherit QmlModels' functionality. We need to propagate that dependency to QML via qmldir entry, otherwise we won't be able to see the types in QmlCompiler lib Note that we already depend more strongly (via linking) on the QmlModels library, so there is no reason not to depend on the QML module in qmldir Pick-to: 6.2 6.3 Change-Id: I4f16f66f2910fb6afd38475cd6ba3209cfd1207d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-28 11:45:35 +00:00
void labsQmlModelsSanity();
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#endif
void unknownCppBase();
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
void groupedProperties();
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
public:
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
tst_qqmljsscope()
: QQmlDataTest(QT_QMLTEST_DATADIR),
m_importer(
{
QLibraryInfo::path(QLibraryInfo::QmlImportsPath),
dataDirectory(),
},
nullptr)
{
}
private:
QQmlJSImporter m_importer;
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
};
void tst_qqmljsscope::initTestCase()
{
QQmlDataTest::initTestCase();
QDirIterator it(dataDirectory(), QDirIterator::FollowSymlinks | QDirIterator::Subdirectories);
while (it.hasNext()) {
const QString url = it.next();
if (!url.endsWith(u".qml"_qs)) // not interesting
continue;
const QFileInfo fi(url);
QVERIFY(fi.exists());
QFile f(fi.absoluteFilePath());
QVERIFY(f.open(QIODevice::ReadOnly));
}
}
void tst_qqmljsscope::orderedBindings()
{
QQmlJSScope::ConstPtr root = run(u"orderedBindings.qml"_qs);
QVERIFY(root);
auto [pBindingsBegin, pBindingsEnd] = root->ownPropertyBindings(u"p"_qs);
QVERIFY(std::distance(pBindingsBegin, pBindingsEnd) == 2);
// check that the bindings are properly ordered
QCOMPARE(pBindingsBegin->bindingType(), QQmlJSMetaPropertyBinding::Object);
QCOMPARE(std::next(pBindingsBegin)->bindingType(), QQmlJSMetaPropertyBinding::Interceptor);
QQmlJSImportVisitor: record UiArrayBinding as binding UiArrayBinding stores object bindings for list<Type> properties (where Type is, or is derived from, QtObject) Test the change both in qmllint (with an ordinary "it reports warnings when needed") and by introspecting QQmlJSScope. In the latter case we can also ensure that the bindings are recorded in the correct order Fixes: QTBUG-93358 Change-Id: Ib5544ba339e22ea899191483a5ba53f755314daa Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-24 08:53:10 +00:00
auto [itemsBindingsBegin, itemsBindingsEnd] = root->ownPropertyBindings(u"items"_qs);
QVERIFY(std::distance(itemsBindingsBegin, itemsBindingsEnd) == 2);
QCOMPARE(itemsBindingsBegin->bindingType(), QQmlJSMetaPropertyBinding::Object);
QCOMPARE(std::next(itemsBindingsBegin)->bindingType(), QQmlJSMetaPropertyBinding::Object);
QCOMPARE(itemsBindingsBegin->objectType()->baseTypeName(), u"Item"_qs);
QCOMPARE(std::next(itemsBindingsBegin)->objectType()->baseTypeName(), u"Text"_qs);
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
}
Distinguish property change signals from user-defined signals Do not expose this information to qmltypes just yet, though, as this seems irrelevant at the moment Pick-to: 6.3 Change-Id: Iffd8901ef9899a0fff226e8799bf45c1d688b92b Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-01-27 14:02:00 +00:00
void tst_qqmljsscope::signalCreationDifferences()
{
QQmlJSScope::ConstPtr root = run(u"signalCreationDifferences.qml"_qs);
QVERIFY(root);
QVERIFY(root->hasOwnProperty(u"myProperty"_qs));
QVERIFY(root->hasOwnProperty(u"conflictingProperty"_qs));
QCOMPARE(root->ownMethods(u"mySignal"_qs).size(), 1);
const auto conflicting = root->ownMethods(u"conflictingPropertyChanged"_qs);
QCOMPARE(conflicting.size(), 2);
QCOMPARE(conflicting[0].methodType(), QQmlJSMetaMethod::Signal);
QCOMPARE(conflicting[1].methodType(), QQmlJSMetaMethod::Signal);
const QQmlJSMetaMethod *explicitMethod = nullptr;
if (conflicting[0].isImplicitQmlPropertyChangeSignal())
explicitMethod = &conflicting[1];
else
explicitMethod = &conflicting[0];
QCOMPARE(explicitMethod->parameterNames(), QStringList({ u"a"_qs, u"c"_qs }));
}
QmlCompiler: Discern between internal and anonymous imports Anonymous imports are imports of QML types that aren't visible in the current document. Internal imports are imports of C++ types, also invisible, but potentially of the same names. Before, types with exports were added to the qmltypes container using their exports if any matched. If there were no exports, we constructed a synthetic name and inserted that. However, as the nullptr example shows, we need a reliable way to find them by their internal names, no matter if exports are present. Therefore, we now consistently add them by their internal names using the new $internal$ prefix. Change-Id: I42ac2447cd924d09970c24554e1e2a5e631c5f79 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-03 13:39:58 +00:00
void tst_qqmljsscope::allTypesAvailable()
{
const QStringList importPaths = {
QLibraryInfo::path(QLibraryInfo::QmlImportsPath),
dataDirectory(),
};
QQmlJSImporter importer { importPaths, /* resource file mapper */ nullptr };
const auto types = importer.importModule(u"QtQml"_qs);
QVERIFY(types.contains(u"$internal$.QObject"_qs));
QVERIFY(types.contains(u"QtObject"_qs));
QCOMPARE(types[u"$internal$.QObject"_qs].scope, types[u"QtObject"_qs].scope);
}
qmllint: Make "Did you mean" look in extension types as well Makes sure we also look for suggestions in extension types. Adds two new methods to QQmlJSScope called properties() and methods() to easily get all of them across base types and extensions. Change-Id: I5874c0221bac6d6e317b79146227bf749100f05b Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-11 15:03:18 +00:00
void tst_qqmljsscope::shadowing()
{
QQmlJSScope::ConstPtr root = run(u"shadowing.qml"_qs);
QVERIFY(root);
QVERIFY(root->baseType());
// Check whether properties are properly shadowed
const auto properties = root->properties();
QVERIFY(properties.contains(u"property_not_shadowed"_qs));
QVERIFY(properties.contains(u"property_shadowed"_qs));
QCOMPARE(properties[u"property_not_shadowed"_qs].typeName(), u"QString"_qs);
QCOMPARE(properties[u"property_shadowed"_qs].typeName(), u"int"_qs);
// Check whether methods are properly shadowed
const auto methods = root->methods();
QCOMPARE(methods.count(u"method_not_shadowed"_qs), 1);
QCOMPARE(methods.count(u"method_shadowed"_qs), 1);
QCOMPARE(methods[u"method_not_shadowed"_qs].parameterNames().size(), 1);
QCOMPARE(methods[u"method_shadowed"_qs].parameterNames().size(), 0);
}
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#ifdef LABS_QML_MODELS_PRESENT
void tst_qqmljsscope::componentWrappedObjects()
{
QQmlJSScope::ConstPtr root = run(u"componentWrappedObjects.qml"_qs);
QVERIFY(root);
auto children = root->childScopes();
QCOMPARE(children.size(), 4);
const auto isGoodType = [](const QQmlJSScope::ConstPtr &type, const QString &propertyName,
bool isWrapped) {
return type->hasOwnProperty(propertyName)
&& type->isWrappedInImplicitComponent() == isWrapped;
};
QVERIFY(isGoodType(children[0], u"nonWrapped1"_qs, false));
QVERIFY(isGoodType(children[1], u"nonWrapped2"_qs, false));
QVERIFY(isGoodType(children[2], u"nonWrapped3"_qs, false));
QVERIFY(isGoodType(children[3], u"wrapped"_qs, true));
}
Add QmlModels dependency to LabsQmlModels Some classes (e.g. QQmlDelegateChooser) depend-on / inherit QmlModels' functionality. We need to propagate that dependency to QML via qmldir entry, otherwise we won't be able to see the types in QmlCompiler lib Note that we already depend more strongly (via linking) on the QmlModels library, so there is no reason not to depend on the QML module in qmldir Pick-to: 6.2 6.3 Change-Id: I4f16f66f2910fb6afd38475cd6ba3209cfd1207d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-03-28 11:45:35 +00:00
void tst_qqmljsscope::labsQmlModelsSanity()
{
QQmlJSScope::ConstPtr root = run(u"labsQmlModelsSanity.qml"_qs);
QVERIFY(root);
auto children = root->childScopes();
QCOMPARE(children.size(), 1);
// DelegateChooser: it inherits QQmlAbstractDelegateComponent (from
// QmlModels) which inherits QQmlComponent. While
// QQmlAbstractDelegateComponent has no properties, QQmlComponent does. If
// the QmlModels dependency is lost, we don't "see" that DelegateChooser
// inherits QQmlComponent - and so has no properties from it, hence, we can
// test exactly that:
QVERIFY(children[0]->hasProperty(u"progress"_qs));
QVERIFY(children[0]->hasProperty(u"status"_qs));
QVERIFY(children[0]->hasProperty(u"url"_qs));
}
Rework QQmlJSScope::causesImplicitComponentWrapping() It does not seem correct to be able to use this function for both sides of binding expressions: the property type and the assigned QML type (`<property> : <qml type> {}`). Instead, it should really be a function that considers both sides together (and actually checks the sides differently!) What we really should do for the assigned QML type is figure whether its *first* non-composite base is a QQmlComponent - not just that it is a QQmlComponent itself. Leave the QQmlAbstractDelegateComponent check in place since this part is correct The property itself, on the other hand, seems to cause an implicit component wrapping if its type is QQmlComponent-derived (which means we have to check the full C++ hierarchy) As a drive by, also update QQmlJSScope::canAssign() since it used the old function internally and was ignoring the case when a to-be-assigned type lacks a C++ base type hierarchy (e.g. because it does not exist ahead of time) Pick-to: 6.3 Change-Id: I23524fa54d45d9140e1cafd9f81ef1f68d95f3a7 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2022-03-15 15:43:38 +00:00
#endif
void tst_qqmljsscope::unknownCppBase()
{
QQmlJSScope::ConstPtr root = run(u"unknownCppBaseAssigningToVar.qml"_qs);
QVERIFY(root);
// we should not crash here, then it is a success
}
qmlcompiler: Improve grouped property support Still lacks support for merging and resolving grouped bindings, but this will be handled in another patch. Task-number: QTBUG-100168 Original-patch-by: Fabian Kosmale <fabian.kosmale@qt.io> Change-Id: I1bb73f383acc3c8512676db47c5944f369b904b7 Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2022-03-18 13:16:09 +00:00
void tst_qqmljsscope::groupedProperties()
{
QQmlJSScope::ConstPtr root = run(u"groupProperties.qml"_qs);
QVERIFY(root);
QVERIFY(root->hasProperty(u"anchors"_qs));
auto anchorBindings = root->propertyBindings(u"anchors"_qs);
QVERIFY(!anchorBindings.isEmpty());
}
Add basic test infrastructure for QQmlJSScope There are already cases which couldn't be covered by qmllint (or qmltc) Sometimes what we really want is a deep introspection into the type hierarchy and the only solution is to exercise whatever things like QQmlJSImportVisitor output Change-Id: Ibe40249aec05f04b46c32466265ea704c35e70a4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-11-23 12:44:58 +00:00
QTEST_MAIN(tst_qqmljsscope)
#include "tst_qqmljsscope.moc"