From 1925d2c977a797b503b4de47d69a8bc8101fe9e8 Mon Sep 17 00:00:00 2001 From: Skycoder42 Date: Tue, 31 Jul 2018 21:06:38 +0200 Subject: [PATCH] added coreapp and viewmodel tests --- src/mvvmcore/coreapp.cpp | 5 + src/mvvmcore/coreapp.h | 9 +- tests/auto/mvvmcore/coreapp/coreapp.pro | 19 + tests/auto/mvvmcore/coreapp/testapp.cpp | 27 ++ tests/auto/mvvmcore/coreapp/testapp.h | 29 ++ tests/auto/mvvmcore/coreapp/testpresenter.cpp | 15 + tests/auto/mvvmcore/coreapp/testpresenter.h | 24 ++ tests/auto/mvvmcore/coreapp/testviewmodel.cpp | 42 ++ tests/auto/mvvmcore/coreapp/testviewmodel.h | 52 +++ tests/auto/mvvmcore/coreapp/tst_coreapp.cpp | 396 ++++++++++++++++++ tests/auto/mvvmcore/mvvmcore.pro | 13 +- 11 files changed, 624 insertions(+), 7 deletions(-) create mode 100644 tests/auto/mvvmcore/coreapp/coreapp.pro create mode 100644 tests/auto/mvvmcore/coreapp/testapp.cpp create mode 100644 tests/auto/mvvmcore/coreapp/testapp.h create mode 100644 tests/auto/mvvmcore/coreapp/testpresenter.cpp create mode 100644 tests/auto/mvvmcore/coreapp/testpresenter.h create mode 100644 tests/auto/mvvmcore/coreapp/testviewmodel.cpp create mode 100644 tests/auto/mvvmcore/coreapp/testviewmodel.h create mode 100644 tests/auto/mvvmcore/coreapp/tst_coreapp.cpp diff --git a/src/mvvmcore/coreapp.cpp b/src/mvvmcore/coreapp.cpp index cd23e1a..9accab5 100644 --- a/src/mvvmcore/coreapp.cpp +++ b/src/mvvmcore/coreapp.cpp @@ -129,6 +129,11 @@ void CoreApp::registerInputTypeMapping(const QByteArray &type, int targetType) CoreAppPrivate::dInstance()->inputTypeMapping.insert(type, targetType); } +IPresenter *CoreApp::presenter() +{ + return CoreAppPrivate::dInstance()->presenter; +} + void CoreApp::bootApp() { if(!d->presenter) { diff --git a/src/mvvmcore/coreapp.h b/src/mvvmcore/coreapp.h index a3aee9b..ea8ca9f 100644 --- a/src/mvvmcore/coreapp.h +++ b/src/mvvmcore/coreapp.h @@ -52,6 +52,8 @@ public: template static void registerInputTypeMapping(const QByteArray &type); + static IPresenter *presenter(); + public Q_SLOTS: //! Boots up the app and starts the mvvm presenting void bootApp(); @@ -95,13 +97,14 @@ void CoreApp::registerInputTypeMapping(const QByteArray &type) } //! Registers you custom CoreApp class as CoreApp to be used -#define QTMVVM_REGISTER_CORE_APP(T) \ - static void _setup_ ## T ## _hook() { \ +#define QTMVVM_REGISTER_CORE_APP(T) namespace {\ + void __setup_ ## T ## _hook() { \ static_assert(std::is_base_of::value, "QTMVVM_REGISTER_CORE_APP must be used with a class that extends QtMvvm::CoreApp"); \ auto app = new T(nullptr); \ app->registerApp(); \ } \ - Q_COREAPP_STARTUP_FUNCTION(_setup_ ## T ## _hook) + } \ + Q_COREAPP_STARTUP_FUNCTION(__setup_ ## T ## _hook) //! A define as shortcut to the CoreApp. Can be redefined to cast to your custom class type #define coreApp QtMvvm::CoreApp::instance() diff --git a/tests/auto/mvvmcore/coreapp/coreapp.pro b/tests/auto/mvvmcore/coreapp/coreapp.pro new file mode 100644 index 0000000..db8b516 --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/coreapp.pro @@ -0,0 +1,19 @@ +TEMPLATE = app + +QT += testlib mvvmcore +QT -= gui +CONFIG += console +CONFIG -= app_bundle + +TARGET = tst_coreapp + +SOURCES += \ + tst_coreapp.cpp \ + testapp.cpp \ + testpresenter.cpp \ + testviewmodel.cpp + +HEADERS += \ + testapp.h \ + testpresenter.h \ + testviewmodel.h diff --git a/tests/auto/mvvmcore/coreapp/testapp.cpp b/tests/auto/mvvmcore/coreapp/testapp.cpp new file mode 100644 index 0000000..8bf13c0 --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/testapp.cpp @@ -0,0 +1,27 @@ +#include "testapp.h" +#include + +TestApp::TestApp(QObject *parent) : + CoreApp(parent) +{} + +TestPresenter *TestApp::presenter() +{ + return static_cast(CoreApp::presenter()); +} + +void TestApp::performRegistrations() +{ + wasRegistered = true; +} + +int TestApp::startApp(const QStringList &arguments) +{ + startArgs = arguments; + return EXIT_SUCCESS; +} + +void TestApp::closeApp() +{ + wasClosed = false; +} diff --git a/tests/auto/mvvmcore/coreapp/testapp.h b/tests/auto/mvvmcore/coreapp/testapp.h new file mode 100644 index 0000000..df4e7e9 --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/testapp.h @@ -0,0 +1,29 @@ +#ifndef TESTAPP_H +#define TESTAPP_H + +#include +#include "testpresenter.h" + +class TestApp : public QtMvvm::CoreApp +{ + Q_OBJECT + +public: + explicit TestApp(QObject *parent = nullptr); + + bool wasRegistered = false; + QStringList startArgs; + bool wasClosed = false; + + static TestPresenter *presenter(); + +protected: + void performRegistrations() override; + int startApp(const QStringList &arguments) override; + void closeApp() override; +}; + +#undef coreApp +#define coreApp static_cast(QtMvvm::CoreApp::instance()) + +#endif // TESTAPP_H diff --git a/tests/auto/mvvmcore/coreapp/testpresenter.cpp b/tests/auto/mvvmcore/coreapp/testpresenter.cpp new file mode 100644 index 0000000..3d8d1cf --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/testpresenter.cpp @@ -0,0 +1,15 @@ +#include "testpresenter.h" + +TestPresenter::TestPresenter(QObject *parent) : + QObject{parent} +{} + +void TestPresenter::present(QtMvvm::ViewModel *viewModel, const QVariantHash ¶ms, QPointer parent) +{ + presented.append(std::make_tuple(viewModel, params, parent)); + emit presentDone(); +} + +void TestPresenter::showDialog(const QtMvvm::MessageConfig &config, QtMvvm::MessageResult *result) +{ +} diff --git a/tests/auto/mvvmcore/coreapp/testpresenter.h b/tests/auto/mvvmcore/coreapp/testpresenter.h new file mode 100644 index 0000000..2fb9ff1 --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/testpresenter.h @@ -0,0 +1,24 @@ +#ifndef TESTPRESENTER_H +#define TESTPRESENTER_H + +#include +#include + +class TestPresenter : public QObject, public QtMvvm::IPresenter +{ + Q_OBJECT + Q_INTERFACES(QtMvvm::IPresenter) + +public: + Q_INVOKABLE explicit TestPresenter(QObject *parent = nullptr); + + void present(QtMvvm::ViewModel *viewModel, const QVariantHash ¶ms, QPointer parent) override; + void showDialog(const QtMvvm::MessageConfig &config, QtMvvm::MessageResult *result) override; + + QList>> presented; + +Q_SIGNALS: + void presentDone(); +}; + +#endif // TESTPRESENTER_H diff --git a/tests/auto/mvvmcore/coreapp/testviewmodel.cpp b/tests/auto/mvvmcore/coreapp/testviewmodel.cpp new file mode 100644 index 0000000..34745dd --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/testviewmodel.cpp @@ -0,0 +1,42 @@ +#include "testviewmodel.h" + +TestViewModel::TestViewModel(QObject *parent) : + ViewModel(parent) +{} + +void TestViewModel::presenChild(const QVariantHash ¶ms) +{ + show(params); +} + +void TestViewModel::presentResult(quint32 code) +{ + showForResult(code); +} + +void TestViewModel::onInit(const QVariantHash ¶ms) +{ +} + +void TestViewModel::onResult(quint32 requestCode, const QVariant &result) +{ + results.append(std::make_tuple(requestCode, result)); +} + + + +TestSingleViewModel::TestSingleViewModel(QObject *parent) : + ViewModel(parent) +{} + + + +TestContainedViewModel::TestContainedViewModel(QObject *parent) : + ViewModel(parent) +{} + + + +TestContainedSingleViewModel::TestContainedSingleViewModel(QObject *parent) : + ViewModel(parent) +{} diff --git a/tests/auto/mvvmcore/coreapp/testviewmodel.h b/tests/auto/mvvmcore/coreapp/testviewmodel.h new file mode 100644 index 0000000..71d38d5 --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/testviewmodel.h @@ -0,0 +1,52 @@ +#ifndef TESTVIEWMODEL_H +#define TESTVIEWMODEL_H + +#include + +class TestViewModel : public QtMvvm::ViewModel +{ + Q_OBJECT + +public: + Q_INVOKABLE explicit TestViewModel(QObject *parent = nullptr); + + void presenChild(const QVariantHash ¶ms = {}); + void presentResult(quint32 code); + + QList> results; + +public Q_SLOTS: + void onInit(const QVariantHash ¶ms) override; + void onResult(quint32 requestCode, const QVariant &result) override; +}; +Q_DECLARE_METATYPE(TestViewModel*) + +class TestSingleViewModel : public QtMvvm::ViewModel +{ + Q_OBJECT + QTMVVM_SINGLETON + +public: + Q_INVOKABLE explicit TestSingleViewModel(QObject *parent = nullptr); +}; +Q_DECLARE_METATYPE(TestSingleViewModel*) + +class TestContainedViewModel : public QtMvvm::ViewModel +{ + Q_OBJECT + QTMVVM_CONTAINER_VM(TestViewModel) + +public: + Q_INVOKABLE explicit TestContainedViewModel(QObject *parent = nullptr); +}; + +class TestContainedSingleViewModel : public QtMvvm::ViewModel +{ + Q_OBJECT + QTMVVM_CONTAINER_VM(TestSingleViewModel) + +public: + Q_INVOKABLE explicit TestContainedSingleViewModel(QObject *parent = nullptr); +}; + +#endif // TESTVIEWMODEL_H diff --git a/tests/auto/mvvmcore/coreapp/tst_coreapp.cpp b/tests/auto/mvvmcore/coreapp/tst_coreapp.cpp new file mode 100644 index 0000000..8847409 --- /dev/null +++ b/tests/auto/mvvmcore/coreapp/tst_coreapp.cpp @@ -0,0 +1,396 @@ +#include +#include +#include "testapp.h" +#include "testviewmodel.h" +using namespace QtMvvm; + +QTMVVM_REGISTER_CORE_APP(TestApp) + +class CoreAppTest : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + void initTestCase(); + + void testAppBoot(); + void testTypeMapping_data(); + void testTypeMapping(); + + void testPresentVm(); + void testPresentVmArgs(); + void testPresentVmChild(); + void testPresentVmForResult(); + void testPresentVmContainer(); + void testPresentVmSingleton(); + + void testPresentDialog(); + void testPresentMessage_data(); + void testPresentMessage(); + void testProgressMessage(); +}; + +void CoreAppTest::initTestCase() +{ + qRegisterMetaType(); + qRegisterMetaType(); + QtMvvm::ServiceRegistry::instance()->registerInterface(); +} + +void CoreAppTest::testAppBoot() +{ + QVERIFY(coreApp); + QVERIFY(coreApp->wasRegistered); + QVERIFY(coreApp->startArgs.isEmpty()); + + QSignalSpy startSpy{coreApp, &TestApp::appStarted}; + QCoreApplication::processEvents(); + QVERIFY(!coreApp->startArgs.isEmpty()); + QCOMPARE(coreApp->startArgs, QCoreApplication::arguments()); + QCOMPARE(startSpy.size(), 1); +} + +void CoreAppTest::testTypeMapping_data() +{ + QTest::addColumn("type"); + QTest::addColumn("targetType"); + QTest::addColumn("value"); + QTest::addColumn("needRegister"); + QTest::addColumn("result"); + + QTest::newRow("builtin.switch") << QByteArrayLiteral("switch") + << static_cast(QMetaType::Bool) + << QVariant{QStringLiteral("true")} + << false + << QVariant{true}; + + QTest::newRow("builtin.string") << QByteArrayLiteral("string") + << static_cast(QMetaType::QString) + << QVariant{QStringLiteral("test")} + << false + << QVariant{QStringLiteral("test")}; + + QTest::newRow("builtin.number") << QByteArrayLiteral("number") + << static_cast(QMetaType::Double) + << QVariant{QStringLiteral("4.2")} + << false + << QVariant{4.2}; + + QTest::newRow("builtin.range") << QByteArrayLiteral("range") + << static_cast(QMetaType::Int) + << QVariant{QStringLiteral("55")} + << false + << QVariant{55}; + + QTest::newRow("builtin.date") << QByteArrayLiteral("date") + << static_cast(QMetaType::QDateTime) + << QVariant{QStringLiteral("2018-10-10T10:10")} + << false + << QVariant{QDateTime{{2018, 10, 10}, {10, 10}}}; + + QTest::newRow("builtin.color") << QByteArrayLiteral("color") + << static_cast(QMetaType::QColor) + << QVariant{QStringLiteral("#123456")} + << false + << QVariant{QColor{0x12, 0x34, 0x56}}; + + QTest::newRow("builtin.url") << QByteArrayLiteral("url") + << static_cast(QMetaType::QUrl) + << QVariant{QStringLiteral("file:///root.txt")} + << false + << QVariant{QUrl::fromLocalFile(QStringLiteral("/root.txt"))}; + + QTest::newRow("builtin.var") << QByteArrayLiteral("var") + << static_cast(QMetaType::QVariant) + << QVariant{42} + << false + << QVariant{42}; + + QTest::newRow("builtin.variant") << QByteArrayLiteral("variant") + << static_cast(QMetaType::QVariant) + << QVariant{43} + << false + << QVariant{43}; + + QTest::newRow("builtin.selection") << QByteArrayLiteral("selection") + << static_cast(QMetaType::QVariant) + << QVariant{44} + << false + << QVariant{44}; + + QTest::newRow("builtin.list") << QByteArrayLiteral("list") + << static_cast(QMetaType::QVariant) + << QVariant{45} + << false + << QVariant{45}; + + QTest::newRow("builtin.radiolist") << QByteArrayLiteral("radiolist") + << static_cast(QMetaType::QVariant) + << QVariant{46} + << false + << QVariant{46}; + + QTest::newRow("known") << QByteArrayLiteral("int") + << static_cast(QMetaType::Int) + << QVariant{QStringLiteral("66")} + << false + << QVariant{66}; + + QTest::newRow("custom") << QByteArrayLiteral("salt") + << static_cast(QMetaType::Double) + << QVariant{QStringLiteral("0.5")} + << true + << QVariant{0.5}; + + QTest::newRow("invalid.unknown") << QByteArrayLiteral("sugar") + << static_cast(QMetaType::Int) + << QVariant{QStringLiteral("66")} + << false + << QVariant{}; + + QTest::newRow("invalid.inconvertible") << QByteArrayLiteral("color") + << static_cast(QMetaType::QColor) + << QVariant{true} + << false + << QVariant{}; +} + +void CoreAppTest::testTypeMapping() +{ + QFETCH(QByteArray, type); + QFETCH(int, targetType); + QFETCH(QVariant, value); + QFETCH(bool, needRegister); + QFETCH(QVariant, result); + + if(needRegister) + CoreApp::registerInputTypeMapping(type, targetType); + + auto res = CoreApp::safeCastInputType(type, value); + if(result.isValid()) { + if(targetType == QMetaType::QVariant) + QVERIFY(res.userType() != targetType); + else + QCOMPARE(res.userType(), targetType); + QVERIFY(res.isValid()); + QCOMPARE(res, result); + } else { + QCOMPARE(res.userType(), value.userType()); + QVERIFY(res.userType() != targetType); + } +} + +void CoreAppTest::testPresentVm() +{ + auto presenter = TestApp::presenter(); + presenter->presented.clear(); + QSignalSpy presentSpy{presenter, &TestPresenter::presentDone}; + CoreApp::show(); + + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 1); + QCOMPARE(presenter->presented.size(), 1); + + auto vm = std::get<0>(presenter->presented[0]); + QVERIFY(vm); + QCOMPARE(vm->metaObject(), &TestViewModel::staticMetaObject); + QVERIFY(std::get<1>(presenter->presented[0]).isEmpty()); + QVERIFY(!std::get<2>(presenter->presented[0])); +} + +void CoreAppTest::testPresentVmArgs() +{ + QVariantHash params { + {QStringLiteral("key"), QStringLiteral("value")}, + {QStringLiteral("baum"), 42} + }; + + auto presenter = TestApp::presenter(); + presenter->presented.clear(); + QSignalSpy presentSpy{presenter, &TestPresenter::presentDone}; + CoreApp::show(params); + + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 1); + QCOMPARE(presenter->presented.size(), 1); + + auto vm = std::get<0>(presenter->presented[0]); + QVERIFY(vm); + QCOMPARE(vm->metaObject(), &TestViewModel::staticMetaObject); + QCOMPARE(std::get<1>(presenter->presented[0]), params); + QVERIFY(!std::get<2>(presenter->presented[0])); +} + +void CoreAppTest::testPresentVmChild() +{ + QVariantHash params { + {QStringLiteral("key"), QStringLiteral("value")}, + {QStringLiteral("baum"), 42} + }; + + auto presenter = TestApp::presenter(); + presenter->presented.clear(); + QSignalSpy presentSpy{presenter, &TestPresenter::presentDone}; + CoreApp::show(); + + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 1); + QCOMPARE(presenter->presented.size(), 1); + + auto vm = static_cast(std::get<0>(presenter->presented[0])); + QVERIFY(vm); + + vm->presenChild(params); + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 2); + QCOMPARE(presenter->presented.size(), 2); + + auto child = std::get<0>(presenter->presented[1]); + QVERIFY(child); + QCOMPARE(child->metaObject(), &TestViewModel::staticMetaObject); + QCOMPARE(std::get<1>(presenter->presented[1]), params); + QCOMPARE(std::get<2>(presenter->presented[1]), vm); +} + +void CoreAppTest::testPresentVmForResult() +{ + auto presenter = TestApp::presenter(); + presenter->presented.clear(); + QSignalSpy presentSpy{presenter, &TestPresenter::presentDone}; + CoreApp::show(); + + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 1); + QCOMPARE(presenter->presented.size(), 1); + + auto vm = static_cast(std::get<0>(presenter->presented[0])); + QVERIFY(vm); + + // show with result + vm->presentResult(42); + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 2); + QCOMPARE(presenter->presented.size(), 2); + + auto child = std::get<0>(presenter->presented[1]); + QVERIFY(child); + QCOMPARE(child->metaObject(), &TestViewModel::staticMetaObject); + QVERIFY(std::get<1>(presenter->presented[1]).isEmpty()); + QCOMPARE(std::get<2>(presenter->presented[1]), vm); + + QVariant result{5.5}; + emit child->resultReady(result); + QCOMPARE(vm->results.size(), 1); + QCOMPARE(std::get<0>(vm->results[0]), 42u); + QCOMPARE(std::get<1>(vm->results[0]), result); + delete child; + QCOMPARE(vm->results.size(), 1); + + //show without result + vm->presentResult(24); + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 3); + QCOMPARE(presenter->presented.size(), 3); + + child = std::get<0>(presenter->presented[2]); + QVERIFY(child); + + delete child; + QCOMPARE(vm->results.size(), 2); + QCOMPARE(std::get<0>(vm->results[1]), 24u); + QVERIFY(!std::get<1>(vm->results[1]).isValid()); +} + +void CoreAppTest::testPresentVmContainer() +{ + QVariantHash initMap { + {QStringLiteral("qtmvvm_container_for"), QByteArray{TestContainedViewModel::staticMetaObject.className()}}, + {QStringLiteral("qtmvvm_child_params"), QVariantHash{}} + }; + + auto presenter = TestApp::presenter(); + presenter->presented.clear(); + QSignalSpy presentSpy{presenter, &TestPresenter::presentDone}; + CoreApp::show(); + + while(presentSpy.size() < 2) + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 2); + QCOMPARE(presenter->presented.size(), 2); + + auto vm = std::get<0>(presenter->presented[0]); + QVERIFY(vm); + QCOMPARE(vm->metaObject(), &TestViewModel::staticMetaObject); + QCOMPARE(std::get<1>(presenter->presented[0]), initMap); + QVERIFY(!std::get<2>(presenter->presented[0])); + + auto child = std::get<0>(presenter->presented[1]); + QVERIFY(child); + QCOMPARE(child->metaObject(), &TestContainedViewModel::staticMetaObject); + QVERIFY(std::get<1>(presenter->presented[1]).isEmpty()); + QCOMPARE(std::get<2>(presenter->presented[1]), vm); +} + +void CoreAppTest::testPresentVmSingleton() +{ + auto presenter = TestApp::presenter(); + presenter->presented.clear(); + QSignalSpy presentSpy{presenter, &TestPresenter::presentDone}; + CoreApp::show(); + + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 1); + QCOMPARE(presenter->presented.size(), 1); + + auto vm = std::get<0>(presenter->presented[0]); + QVERIFY(vm); + QCOMPARE(vm->metaObject(), &TestSingleViewModel::staticMetaObject); + QVERIFY(std::get<1>(presenter->presented[0]).isEmpty()); + QVERIFY(!std::get<2>(presenter->presented[0])); + + QSignalSpy instSpy{vm, &ViewModel::instanceInvoked}; + + CoreApp::show(); + QVERIFY(!presentSpy.wait()); + QCOMPARE(presentSpy.size(), 1); + QCOMPARE(presenter->presented.size(), 1); + QCOMPARE(instSpy.size(), 1); + + // test single container + CoreApp::show(); + + QVERIFY(presentSpy.wait()); + QCOMPARE(presentSpy.size(), 2); + QCOMPARE(presenter->presented.size(), 2); + + auto child = std::get<0>(presenter->presented[1]); + QVERIFY(child); + QCOMPARE(child->metaObject(), &TestContainedSingleViewModel::staticMetaObject); + QVERIFY(std::get<1>(presenter->presented[1]).isEmpty()); + QCOMPARE(std::get<2>(presenter->presented[1]), vm); + QCOMPARE(instSpy.size(), 2); +} + +void CoreAppTest::testPresentDialog() +{ + Q_UNIMPLEMENTED(); +} + +void CoreAppTest::testPresentMessage_data() +{ + Q_UNIMPLEMENTED(); +} + +void CoreAppTest::testPresentMessage() +{ + Q_UNIMPLEMENTED(); +} + +void CoreAppTest::testProgressMessage() +{ + Q_UNIMPLEMENTED(); +} + +QTEST_MAIN(CoreAppTest) + +#include "tst_coreapp.moc" diff --git a/tests/auto/mvvmcore/mvvmcore.pro b/tests/auto/mvvmcore/mvvmcore.pro index 3b7ad87..fed37c2 100644 --- a/tests/auto/mvvmcore/mvvmcore.pro +++ b/tests/auto/mvvmcore/mvvmcore.pro @@ -4,10 +4,15 @@ SUBDIRS += \ settingsgenerator \ serviceregistry \ serviceregistrytestplugin \ - binding \ - qsettingsaccessor \ - settingsconfigloader + binding \ + qsettingsaccessor \ + settingsconfigloader \ + coreapp serviceregistry.depends += serviceregistrytestplugin -equals(MSVC_VER, 14.0): SUBDIRS -= settingsgenerator +equals(MSVC_VER, 14.0) { + SUBDIRS -= \ + settingsgenerator \ + settingsconfigloader +}