QmlDesigner: Read and apply minimumVersion for material bundles

If `minQtVersion` exists for a material in material_bundle.json file,
and kit version is less than `minQtVersion`, the material should be
skipped.
Version class has improved and moved to QmlDesignerUtils.

Task-number: QDS-13274
Change-Id: I726c1765c69e5b080650099d0b811a90cfc3ccf5
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>
Reviewed-by: Marco Bubke <marco.bubke@qt.io>

src/plugins/qmldesigner/CMakeLists.txt

@@ -48,6 +48,7 @@ add_qtc_library(QmlDesignerUtils STATIC
     ktximage.cpp ktximage.h
     imageutils.cpp imageutils.h
     qmldesignerutils_global.h
+    version.cpp version.h
 )
 
 extend_qtc_library(QmlDesignerUtils

src/plugins/qmldesigner/components/contentlibrary/contentlibrarymaterialsmodel.cpp

@@ -211,11 +211,11 @@ QString ContentLibraryMaterialsModel::bundleId() const
     return m_bundleId;
 }
 
-void ContentLibraryMaterialsModel::loadMaterialBundle()
+void ContentLibraryMaterialsModel::loadMaterialBundle(bool forceReload)
 {
     auto compUtils = QmlDesignerPlugin::instance()->documentManager().generatedComponentUtils();
 
-    if (m_bundleExists && m_bundleId == compUtils.materialsBundleId())
+    if (!forceReload && m_bundleExists && m_bundleId == compUtils.materialsBundleId())
         return;
 
     // clean up
@@ -257,6 +257,13 @@ void ContentLibraryMaterialsModel::loadMaterialBundle()
         for (const QString &matName : matsNames) {
             const QJsonObject matObj = matsObj.value(matName).toObject();
 
+            if (matObj.contains("minQtVersion")) {
+                const Version minQtVersion = Version::fromString(
+                    matObj.value("minQtVersion").toString());
+                if (minQtVersion > m_quick3dVersion)
+                    continue;
+            }
+
             QStringList files;
             const QJsonArray assetsArr = matObj.value("files").toArray();
             for (const QJsonValueConstRef &asset : assetsArr)
@@ -289,7 +296,7 @@ void ContentLibraryMaterialsModel::loadMaterialBundle()
 
 bool ContentLibraryMaterialsModel::hasRequiredQuick3DImport() const
 {
-    return m_widget->hasQuick3DImport() && m_quick3dMajorVersion == 6 && m_quick3dMinorVersion >= 3;
+    return m_widget->hasQuick3DImport() && m_quick3dVersion >= Version{6, 3};
 }
 
 bool ContentLibraryMaterialsModel::matBundleExists() const
@@ -335,8 +342,11 @@ void ContentLibraryMaterialsModel::setQuick3DImportVersion(int major, int minor)
 {
     bool oldRequiredImport = hasRequiredQuick3DImport();
 
-    m_quick3dMajorVersion = major;
+    const Version newVersion{major, minor};
-    m_quick3dMinorVersion = minor;
+    if (m_quick3dVersion != newVersion) {
+        m_quick3dVersion = newVersion;
+        loadMaterialBundle(true);
+    }
 
     bool newRequiredImport = hasRequiredQuick3DImport();
 

src/plugins/qmldesigner/components/contentlibrary/contentlibrarymaterialsmodel.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <utils/filepath.h>
+#include <utils/version.h>
 
 #include <QAbstractListModel>
 #include <QJsonObject>
@@ -60,7 +61,7 @@ signals:
     void matBundleExistsChanged();
 
 private:
-    void loadMaterialBundle();
+    void loadMaterialBundle(bool forceReload = false);
     bool fetchBundleIcons();
     bool fetchBundleJsonFile();
     bool isValidIndex(int idx) const;
@@ -76,9 +77,7 @@ private:
     bool m_isEmpty = true;
     bool m_bundleExists = false;
 
-    int m_quick3dMajorVersion = -1;
+    Version m_quick3dVersion;
-    int m_quick3dMinorVersion = -1;
-
     Utils::FilePath m_bundlePath;
     QString m_baseUrl;
 };

src/plugins/qmldesigner/components/itemlibrary/itemlibrarymodel.cpp

@@ -14,10 +14,11 @@
 #include <nodemetainfo.h>
 #include <projectexplorer/project.h>
 #include <projectexplorer/projectmanager.h>
-#include "qmldesignerconstants.h"
+#include <qmldesignerconstants.h>
-#include "qmldesignerplugin.h"
+#include <qmldesignerplugin.h>
 #include <utils/algorithm.h>
 #include <utils/qtcassert.h>
+#include <utils/version.h>
 
 #include <QIODevice>
 #include <QLoggingCategory>

src/plugins/qmldesigner/designercore/include/import.h

@@ -12,37 +12,9 @@
 
 #include "qmldesignercorelib_global.h"
 
-#include <limits>
-
 namespace QmlDesigner {
 
-class Version
+class Version;
-{
-public:
-    friend bool operator==(Version first, Version second)
-    {
-        return first.major == second.major && first.minor == second.minor;
-    }
-
-    friend bool operator<(Version first, Version second)
-    {
-        return std::tie(first.major, first.minor) < std::tie(second.major, second.minor);
-    }
-
-    friend bool operator>(Version first, Version second) { return second < first; }
-    friend bool operator<=(Version first, Version second) { return !(second < first); }
-    friend bool operator>=(Version first, Version second) { return !(first < second); }
-
-    bool isEmpty() const
-    {
-        return major == std::numeric_limits<int>::max() || minor == std::numeric_limits<int>::max();
-    }
-
-public:
-    int major = std::numeric_limits<int>::max();
-    int minor = std::numeric_limits<int>::max();
-};
-
 class QMLDESIGNERCORE_EXPORT Import
 {
     using Imports = QList<Import>;

src/plugins/qmldesigner/designercore/model/import.cpp

@@ -3,6 +3,8 @@
 
 #include "import.h"
 
+#include <qmldesigner/utils/version.h>
+
 #include <QHash>
 
 #include <QStringView>

src/plugins/qmldesigner/designercore/model/model.cpp

@@ -40,6 +40,7 @@
 #include <qmljs/qmljsmodelmanagerinterface.h>
 
 #include <utils/algorithm.h>
+#include <utils/version.h>
 
 #include <QDrag>
 #include <QFileInfo>

src/plugins/qmldesigner/utils/version.cpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+#include "version.h"
+
+#include <QDebug>
+#include <QList>
+
+namespace QmlDesigner {
+
+Version Version::fromString(QStringView string)
+{
+    Version result;
+    // Split version into parts (major, minor, patch)
+    QList<QStringView> versionParts = string.split('.');
+
+    auto readDigit = [](QStringView string, int defaultValue = 0) -> int {
+        bool canConvert = false;
+        int digit = string.toInt(&canConvert);
+        return (canConvert && digit > -1) ? digit : defaultValue;
+    };
+
+    if (versionParts.size() > 0)
+        result.major = readDigit(versionParts[0], std::numeric_limits<int>::max());
+
+    if (versionParts.size() > 1)
+        result.minor = readDigit(versionParts[1]);
+
+    if (versionParts.size() > 2)
+        result.patch = readDigit(versionParts[2]);
+
+    return result;
+}
+
+QString Version::toString() const
+{
+    if (isEmpty())
+        return {};
+
+    return QString("%1.%2.%3").arg(major).arg(minor).arg(patch);
+}
+
+QDebug operator<<(QDebug debug, Version version)
+{
+    return debug.noquote() << QStringView(u"Version(%1)").arg(version.toString());
+}
+
+} // namespace QmlDesigner

src/plugins/qmldesigner/utils/version.h

@@ -0,0 +1,52 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include "qmldesignerutils_global.h"
+
+#include <limits>
+#include <QString>
+
+QT_BEGIN_NAMESPACE
+class QDebug;
+QT_END_NAMESPACE
+
+namespace QmlDesigner {
+
+class Version
+{
+public:
+    static Version QMLDESIGNERUTILS_EXPORT fromString(QStringView string);
+
+    QString QMLDESIGNERUTILS_EXPORT toString() const;
+
+    bool isEmpty() const { return major == std::numeric_limits<int>::max(); }
+
+    friend bool operator==(Version first, Version second)
+    {
+        return std::tie(first.major, first.minor, first.patch)
+               == std::tie(second.major, second.minor, second.patch);
+    }
+
+    friend bool operator<(Version first, Version second)
+    {
+        return std::tie(first.major, first.minor, first.patch)
+               < std::tie(second.major, second.minor, second.patch);
+    }
+
+    friend bool operator>(Version first, Version second) { return second < first; }
+
+    friend bool operator<=(Version first, Version second) { return !(second < first); }
+
+    friend bool operator>=(Version first, Version second) { return !(first < second); }
+
+    friend QMLDESIGNERUTILS_EXPORT QDebug operator<<(QDebug debug, Version version);
+
+public:
+    int major = std::numeric_limits<int>::max();
+    int minor = 0;
+    int patch = 0;
+};
+
+} // namespace QmlDesigner

tests/unit/tests/unittests/designercoreutils/CMakeLists.txt

@@ -1,6 +1,9 @@
 # qmldesigner/designercore/model
 extend_qtc_test(unittest
+  DEPENDS
+    QmlDesignerUtils
   SOURCES
     modelutils-test.cpp
     uniquename-test.cpp
+    version-test.cpp
 )

tests/unit/tests/unittests/designercoreutils/version-test.cpp

@@ -0,0 +1,341 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <googletest.h>
+#include <utils/version.h>
+
+namespace {
+
+TEST(Version, same_versions_are_equal)
+{
+    QmlDesigner::Version version1{6, 5, 2};
+    QmlDesigner::Version version2{6, 5, 2};
+
+    bool isEqual = version1 == version2;
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(Version, invalid_versions_are_equal)
+{
+    QmlDesigner::Version version1;
+    QmlDesigner::Version version2;
+
+    bool isEqual = version1 == version2;
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(Version, different_minor_versions_are_not_equal)
+{
+    QmlDesigner::Version version1{6, 4};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isEqual = version1 == version2;
+
+    ASSERT_FALSE(isEqual);
+}
+
+TEST(Version, different_major_versions_are_not_equal)
+{
+    QmlDesigner::Version version1{5, 5};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isEqual = version1 == version2;
+
+    ASSERT_FALSE(isEqual);
+}
+
+TEST(Version, different_patch_versions_are_not_equal)
+{
+    QmlDesigner::Version version1{6, 5, 1};
+    QmlDesigner::Version version2{6, 5, 2};
+
+    bool isEqual = version1 == version2;
+
+    ASSERT_FALSE(isEqual);
+}
+
+TEST(Version, less_minor_versions_are_less)
+{
+    QmlDesigner::Version version1{6, 4};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLess = version1 < version2;
+
+    ASSERT_TRUE(isLess);
+}
+
+TEST(Version, less_major_versions_are_less)
+{
+    QmlDesigner::Version version1{5, 15};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLess = version1 < version2;
+
+    ASSERT_TRUE(isLess);
+}
+
+TEST(Version, less_patch_versions_are_less)
+{
+    QmlDesigner::Version version1{6, 5, 3};
+    QmlDesigner::Version version2{6, 5, 15};
+
+    bool isLess = version1 < version2;
+
+    ASSERT_TRUE(isLess);
+}
+
+TEST(Version, same_versions_are_not_less)
+{
+    QmlDesigner::Version version1{6, 5, 1};
+    QmlDesigner::Version version2{6, 5, 1};
+
+    bool isLess = version1 < version2;
+
+    ASSERT_FALSE(isLess);
+}
+
+TEST(Version, empty_version_is_not_less)
+{
+    QmlDesigner::Version version1;
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLess = version1 < version2;
+
+    ASSERT_FALSE(isLess);
+}
+
+TEST(Version, non_empty_version_is_is_less_than_empty_version)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2;
+
+    bool isLess = version1 < version2;
+
+    ASSERT_TRUE(isLess);
+}
+
+TEST(Version, greater_minor_versions_are_greater)
+{
+    QmlDesigner::Version version1{6, 6};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isGreater = version1 > version2;
+
+    ASSERT_TRUE(isGreater);
+}
+
+TEST(Version, greater_major_versions_are_greater)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2{5, 15};
+
+    bool isGreater = version1 > version2;
+
+    ASSERT_TRUE(isGreater);
+}
+
+TEST(Version, same_versions_are_not_greater)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isGreater = version1 > version2;
+
+    ASSERT_FALSE(isGreater);
+}
+
+TEST(Version, empty_version_is_greater)
+{
+    QmlDesigner::Version version1;
+    QmlDesigner::Version version2{6, 5};
+
+    bool isGreater = version1 > version2;
+
+    ASSERT_TRUE(isGreater);
+}
+
+TEST(Version, empty_version_is_greater_than_non_empty_version)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2;
+
+    bool isGreater = version1 > version2;
+
+    ASSERT_FALSE(isGreater);
+}
+
+TEST(Version, less_equal_minor_versions_are_less_equal)
+{
+    QmlDesigner::Version version1{6, 4};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLessEqual = version1 <= version2;
+
+    ASSERT_TRUE(isLessEqual);
+}
+
+TEST(Version, lessqual_major_versions_are_lessqual)
+{
+    QmlDesigner::Version version1{5, 15};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLessEqual = version1 <= version2;
+
+    ASSERT_TRUE(isLessEqual);
+}
+
+TEST(Version, same_versions_are_lessqual)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLessEqual = version1 <= version2;
+
+    ASSERT_TRUE(isLessEqual);
+}
+
+TEST(Version, empty_version_is_not_lessqual)
+{
+    QmlDesigner::Version version1;
+    QmlDesigner::Version version2{6, 5};
+
+    bool isLessEqual = version1 <= version2;
+
+    ASSERT_FALSE(isLessEqual);
+}
+
+TEST(Version, non_empty_version_is_is_lessqual_than_empty_version)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2;
+
+    bool isLessEqual = version1 <= version2;
+
+    ASSERT_TRUE(isLessEqual);
+}
+
+TEST(Version, greater_equal_minor_versions_are_greater_equal)
+{
+    QmlDesigner::Version version1{6, 6};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isGreaterEqual = version1 >= version2;
+
+    ASSERT_TRUE(isGreaterEqual);
+}
+
+TEST(Version, greater_equal_major_versions_are_greater_equal)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2{5, 15};
+
+    bool isGreaterEqual = version1 >= version2;
+
+    ASSERT_TRUE(isGreaterEqual);
+}
+
+TEST(Version, same_versions_are_greater_equal)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2{6, 5};
+
+    bool isGreaterEqual = version1 >= version2;
+
+    ASSERT_TRUE(isGreaterEqual);
+}
+
+TEST(Version, empty_version_is_greater_equal)
+{
+    QmlDesigner::Version version1;
+    QmlDesigner::Version version2{6, 5};
+
+    bool isGreaterEqual = version1 >= version2;
+
+    ASSERT_TRUE(isGreaterEqual);
+}
+
+TEST(Version, non_empty_version_is_is_not_greater_equal_than_empty_version)
+{
+    QmlDesigner::Version version1{6, 5};
+    QmlDesigner::Version version2;
+
+    bool isGreaterEqual = version1 >= version2;
+
+    ASSERT_FALSE(isGreaterEqual);
+}
+
+TEST(Version, version_fromString_empty_string_makes_empty_version)
+{
+    QStringView versionStr = u"";
+
+    QmlDesigner::Version version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_TRUE(version.isEmpty());
+}
+
+TEST(Version, version_fromString_is_the_same_as_initialized_version)
+{
+    QStringView versionStr = u"6.9.2";
+
+    QmlDesigner::Version version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_THAT(version, Eq(QmlDesigner::Version{6, 9, 2}));
+}
+
+TEST(Version, version_fromString_sets_zero_for_minor_and_patch)
+{
+    QStringView versionStr = u"6";
+
+    auto version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_THAT(version, FieldsAre(6, 0, 0));
+}
+
+TEST(Version, version_fromString_sets_zero_for_patch)
+{
+    QStringView versionStr = u"6.3";
+
+    auto version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_THAT(version, FieldsAre(6, 3, 0));
+}
+
+TEST(Version, version_fromString_empty_parts_are_zero)
+{
+    QStringView versionStr = u"6.";
+
+    auto version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_THAT(version, FieldsAre(6, 0, 0));
+}
+
+TEST(Version, version_fromString_non_standard_version_is_empty)
+{
+    QStringView versionStr = u"1-beta1";
+
+    auto version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_TRUE(version.isEmpty());
+}
+
+TEST(Version, version_fromString_with_negative_major_is_empty)
+{
+    QStringView versionStr = u"-1";
+
+    auto version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_TRUE(version.isEmpty());
+}
+
+TEST(Version, version_fromString_negative_minor_will_be_changed_to_zero)
+{
+    QStringView versionStr = u"6.-1";
+
+    auto version = QmlDesigner::Version::fromString(versionStr);
+
+    ASSERT_THAT(version, FieldsAre(6, 0, 0));
+}
+
+} // namespace

tests/unit/tests/unittests/model/import-test.cpp

@@ -4,6 +4,7 @@
 #include "../utils/googletest.h"
 
 #include <import.h>
+#include <qmldesigner/utils/version.h>
 
 namespace {
 
@@ -13,7 +14,7 @@ TEST(Import, parse_version)
 
     auto version = import.toVersion();
 
-    ASSERT_THAT(version, FieldsAre(6, 5));
+    ASSERT_THAT(version, FieldsAre(6, 5, 0));
 }
 
 TEST(Import, parse_major_version)
@@ -97,244 +98,4 @@ TEST(Import, empty_version_string_is_empty_version)
     ASSERT_TRUE(version.isEmpty());
 }
 
-TEST(Import, same_versions_are_equal)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isEqual = version1 == version2;
-
-    ASSERT_TRUE(isEqual);
-}
-
-TEST(Import, invalid_versions_are_equal)
-{
-    QmlDesigner::Version version1;
-    QmlDesigner::Version version2;
-
-    bool isEqual = version1 == version2;
-
-    ASSERT_TRUE(isEqual);
-}
-
-TEST(Import, different_minor_versions_are_not_equal)
-{
-    QmlDesigner::Version version1{6, 4};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isEqual = version1 == version2;
-
-    ASSERT_FALSE(isEqual);
-}
-
-TEST(Import, different_major_versions_are_not_equal)
-{
-    QmlDesigner::Version version1{5, 5};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isEqual = version1 == version2;
-
-    ASSERT_FALSE(isEqual);
-}
-
-TEST(Import, less_minor_versions_are_less)
-{
-    QmlDesigner::Version version1{6, 4};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLess = version1 < version2;
-
-    ASSERT_TRUE(isLess);
-}
-
-TEST(Import, less_major_versions_are_less)
-{
-    QmlDesigner::Version version1{5, 15};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLess = version1 < version2;
-
-    ASSERT_TRUE(isLess);
-}
-
-TEST(Import, same_versions_are_not_less)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLess = version1 < version2;
-
-    ASSERT_FALSE(isLess);
-}
-
-TEST(Import, empty_version_is_not_less)
-{
-    QmlDesigner::Version version1;
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLess = version1 < version2;
-
-    ASSERT_FALSE(isLess);
-}
-
-TEST(Import, non_empty_version_is_is_less_than_empty_version)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2;
-
-    bool isLess = version1 < version2;
-
-    ASSERT_TRUE(isLess);
-}
-
-TEST(Import, greater_minor_versions_are_greater)
-{
-    QmlDesigner::Version version1{6, 6};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isGreater = version1 > version2;
-
-    ASSERT_TRUE(isGreater);
-}
-
-TEST(Import, greater_major_versions_are_greater)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{5, 15};
-
-    bool isGreater = version1 > version2;
-
-    ASSERT_TRUE(isGreater);
-}
-
-TEST(Import, same_versions_are_not_greater)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isGreater = version1 > version2;
-
-    ASSERT_FALSE(isGreater);
-}
-
-TEST(Import, empty_version_is_greater)
-{
-    QmlDesigner::Version version1;
-    QmlDesigner::Version version2{6, 5};
-
-    bool isGreater = version1 > version2;
-
-    ASSERT_TRUE(isGreater);
-}
-
-TEST(Import, non_empty_version_is_is_not_greater_than_empty_version)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2;
-
-    bool isGreater = version1 > version2;
-
-    ASSERT_FALSE(isGreater);
-}
-
-TEST(Import, less_equal_minor_versions_are_less_equal)
-{
-    QmlDesigner::Version version1{6, 4};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLessEqual = version1 <= version2;
-
-    ASSERT_TRUE(isLessEqual);
-}
-
-TEST(Import, lessqual_major_versions_are_lessqual)
-{
-    QmlDesigner::Version version1{5, 15};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLessEqual = version1 <= version2;
-
-    ASSERT_TRUE(isLessEqual);
-}
-
-TEST(Import, same_versions_are_lessqual)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLessEqual = version1 <= version2;
-
-    ASSERT_TRUE(isLessEqual);
-}
-
-TEST(Import, empty_version_is_not_lessqual)
-{
-    QmlDesigner::Version version1;
-    QmlDesigner::Version version2{6, 5};
-
-    bool isLessEqual = version1 <= version2;
-
-    ASSERT_FALSE(isLessEqual);
-}
-
-TEST(Import, non_empty_version_is_is_lessqual_than_empty_version)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2;
-
-    bool isLessEqual = version1 <= version2;
-
-    ASSERT_TRUE(isLessEqual);
-}
-
-TEST(Import, greater_equal_minor_versions_are_greater_equal)
-{
-    QmlDesigner::Version version1{6, 6};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isGreaterEqual = version1 >= version2;
-
-    ASSERT_TRUE(isGreaterEqual);
-}
-
-TEST(Import, greater_equal_major_versions_are_greater_equal)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{5, 15};
-
-    bool isGreaterEqual = version1 >= version2;
-
-    ASSERT_TRUE(isGreaterEqual);
-}
-
-TEST(Import, same_versions_are_greater_equal)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2{6, 5};
-
-    bool isGreaterEqual = version1 >= version2;
-
-    ASSERT_TRUE(isGreaterEqual);
-}
-
-TEST(Import, empty_version_is_greater_equal)
-{
-    QmlDesigner::Version version1;
-    QmlDesigner::Version version2{6, 5};
-
-    bool isGreaterEqual = version1 >= version2;
-
-    ASSERT_TRUE(isGreaterEqual);
-}
-
-TEST(Import, non_empty_version_is_is_not_greater_equal_than_empty_version)
-{
-    QmlDesigner::Version version1{6, 5};
-    QmlDesigner::Version version2;
-
-    bool isGreaterEqual = version1 >= version2;
-
-    ASSERT_FALSE(isGreaterEqual);
-}
-
 } // namespace