McuSupport: Create freeRTOS package from JSON

Adjust test JSONs.
Write unit tests.
Adjust existing package creation to support freeRTOS package.

Example JSON:
"freeRTOS": {
    "cmakeVar": "FREERTOS_DIR",
    "defaultValue": "$QUL_BOARD_SDK_DIR/rtos/freertos/freertos_kernel",
    "envVar": "IMXRT1064_FREERTOS_DIR",
    "id": "NXP_FREERTOS_DIR",
    "label": "FreeRTOS SDK for MIMXRT1064-EVK",
    "optional": false,
    "setting": "FreeRTOSSourcePackage_IMXRT1064",
    "type": "path"
}

Change-Id: I25ca9f732cd3a54eebb23b73b7950e11976c0f68
Reviewed-by: Dawid Śliwa <dawid.sliwa@qt.io>
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -692,8 +692,7 @@ McuTargetDescription parseDescriptionJson(const QByteArray &data)
     const PackageDescription toolchainPackage = parsePackage(compiler);
     const PackageDescription toolchainFilePackage = parsePackage(toolchainFile);
     const PackageDescription boardSdkPackage{parsePackage(boardSdk)};
-    const QList<PackageDescription> freeRtosEntries = parsePackages(
+    const PackageDescription freeRtosPackage{parsePackage(freeRTOS)};
-        freeRTOS.value(CMAKE_ENTRIES).toArray());
 
     const QVariantList toolchainVersions = toolchain.value("versions").toArray().toVariantList();
     const auto toolchainVersionsList = Utils::transform<QStringList>(toolchainVersions,
@@ -727,10 +726,8 @@ McuTargetDescription parseDescriptionJson(const QByteArray &data)
              toolchainPackage,
              toolchainFilePackage},
             boardSdkPackage,
-            {
+            {freeRTOS.value("envVar").toString(),
-                freeRTOS.value("envVar").toString(),
+             freeRtosPackage}};
-                freeRtosEntries,
-            }};
 }
 
 // https://doc.qt.io/qtcreator/creator-developing-mcu.html#supported-qt-for-mcus-sdks

src/plugins/mcusupport/mcutargetdescription.h

@@ -83,7 +83,7 @@ struct McuTargetDescription
     struct FreeRTOS
     {
         QString envVar;
-        QList<PackageDescription> packages;
+        PackageDescription package;
     } freeRTOS;
 };
 

src/plugins/mcusupport/mcutargetfactory.cpp

@@ -49,7 +49,6 @@ bool isDesktopToolchain(McuToolChainPackage::ToolChainType type)
            || type == McuToolChainPackage::ToolChainType::GCC;
 }
 
-
 McuPackageVersionDetector *createVersionDetection(const VersionDetection &versionDetection)
 {
     if (!versionDetection.xmlElement.isEmpty() && !versionDetection.xmlAttribute.isEmpty())
@@ -140,7 +139,7 @@ QList<PackageDescription> aggregatePackageEntries(const McuTargetDescription &de
     QList<PackageDescription> result;
     result.append(desc.platform.entries);
     result.append(desc.boardSdk);
-    result.append(desc.freeRTOS.packages);
+    result.append(desc.freeRTOS.package);
     return result;
 }
 

src/plugins/mcusupport/test/armgcc_nxp_1050_json.h

@@ -87,33 +87,28 @@ constexpr auto armgcc_nxp_1050_json = R"({
       }
   },
     "boardSdk": {
-    "versions": [ "2.11.0" ],
-    "id": "NXP_SDK_DIR",
-    "label": "Board SDK for MIMXRT1050-EVK",
         "cmakeVar": "QUL_BOARD_SDK_DIR",
         "envVar": "EVKB_IMXRT1050_SDK_PATH",
+        "id": "NXP_SDK_DIR",
+        "label": "Board SDK for MIMXRT1050-EVK",
+        "optional": false,
         "setting": "EVKB_IMXRT1050_SDK_PATH",
+        "type": "path",
         "versionDetection": {
             "filePattern": "*_manifest_*.xml",
-        "xmlElement": "ksdk",
+            "regex": ".*",
             "xmlAttribute": "version",
-        "regex": ".*"
+            "xmlElement": "ksdk"
         },
-    "type": "path",
+        "versions": ["2.11.0"]
-    "optional": false
     },
     "freeRTOS": {
-    "envVar": "IMXRT1050_FREERTOS_DIR",
-    "cmakeEntries": [
-      {
-        "id": "NXP_FREERTOS_DIR",
-        "label": "FreeRTOS SDK for MIMXRT1050-EVK",
         "cmakeVar": "FREERTOS_DIR",
-        "envVar": "IMXRT1050_FREERTOS_DIR",
         "defaultValue": "$QUL_BOARD_SDK_DIR/rtos/freertos/freertos_kernel",
-        "type": "path",
+        "envVar": "IMXRT1050_FREERTOS_DIR",
-        "optional": false
+        "label": "FreeRTOS SDK for MIMXRT1050-EVK",
-      }
+        "optional": false,
-    ]
+        "setting": "FreeRTOSSourcePackage_IMXRT1050",
+        "type": "path"
     }
 })";

src/plugins/mcusupport/test/armgcc_nxp_1064_json.h

@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2022 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** 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.
+**
+****************************************************************************/
+
+#pragma once
+
+constexpr auto armgcc_nxp_1064_json = R"(
+{
+    "boardSdk": {
+        "cmakeVar": "QUL_BOARD_SDK_DIR",
+        "envVar": "EVK_MIMXRT1064_SDK_PATH",
+        "id": "NXP_SDK_DIR",
+        "label": "Board SDK for MIMXRT1064-EVK",
+        "optional": false,
+        "setting": "EVK_MIMXRT1064_SDK_PATH",
+        "type": "path",
+        "versions": ["2.11.1"]
+    },
+    "compatVersion": "1",
+    "freeRTOS": {
+        "cmakeVar": "FREERTOS_DIR",
+        "defaultValue": "$QUL_BOARD_SDK_DIR/rtos/freertos/freertos_kernel",
+        "envVar": "IMXRT1064_FREERTOS_DIR",
+        "id": "NXP_FREERTOS_DIR",
+        "label": "FreeRTOS SDK for MIMXRT1064-EVK",
+        "optional": false,
+        "setting": "FreeRTOSSourcePackage_IMXRT1064",
+        "type": "path"
+    },
+    "platform": {
+        "cmakeCacheEntries": [
+            {
+                "camekVar": "Qul_ROOT",
+                "id": "Qul_DIR",
+                "label": "Qt for MCUs SDK",
+                "optional": false,
+                "type": "path"
+            },
+            {
+                "camekVar": "MCUXPRESSO_IDE_PATH",
+                "defaultValue": {
+                    "unix": "/usr/local/mcuxpressoide/",
+                    "windows": "$ROOT/nxp/MCUXpressoIDE*"
+                },
+                "id": "MCU_XPRESSO_PATH",
+                "label": "MCUXpresso IDE",
+                "optional": false,
+                "type": "path"
+            }
+        ],
+        "colorDepths": [16],
+        "environmentEntries": [],
+        "id": "MIMXRT1064-EVK-FREERTOS",
+        "pathEntries": [],
+        "vendor": "NXP"
+    },
+    "qulVersion": "2.3.0",
+    "toolchain": {
+        "compiler": {
+            "camekVar": "QUL_TARGET_TOOLCHAIN_DIR",
+            "id": "ARMGCC_DIR",
+            "label": "GNU Arm Embedded Toolchain",
+            "optional": false,
+            "type": "path"
+        },
+        "file": {
+            "camekVar": "CMAKE_TOOLCHAIN_FILE",
+            "defaultValue": "$Qul_ROOT/lib/cmake/Qul/toolchain/armgcc.cmake",
+            "id": "ARMGCC_CMAKE_TOOLCHAIN_FILE",
+            "label": "CMake Toolchain File",
+            "optional": false,
+            "type": "file",
+            "visible": false
+        },
+        "id": "armgcc",
+        "versions": ["9.3.1"]
+    }
+})";

src/plugins/mcusupport/test/armgcc_stm32f769i_freertos_json.h

@@ -26,8 +26,8 @@
 #pragma once
 
 constexpr auto armgcc_stm32f769i_freertos_json = R"({
-  "qulVersion": "@CMAKE_PROJECT_VERSION@",
+  "qulVersion": "2.3.0",
-  "compatVersion": "@COMPATIBILITY_VERSION@",
+  "compatVersion": "1",
   "platform": {
     "id": "STM32F769I-DISCOVERY-FREERTOS",
     "vendor": "ST",
@@ -106,15 +106,11 @@ constexpr auto armgcc_stm32f769i_freertos_json = R"({
   },
   "freeRTOS": {
     "envVar": "STM32F7_FREERTOS_DIR",
-    "cmakeEntries": [
-      {
-        "id": "ST_FREERTOS_DIR",
     "label": "FreeRTOS SDK for STM32F769I-Discovery",
     "cmakeVar": "FREERTOS_DIR",
     "defaultValue": "$QUL_BOARD_SDK_DIR/Middlewares/Third_Party/FreeRTOS/Source",
     "type": "path",
+    "setting": "FreeRTOSSourcePackage_STM32F7",
     "optional": false
   }
-    ]
-  }
 })";

src/plugins/mcusupport/test/iar_nxp_1064_json.h

@@ -30,34 +30,29 @@ constexpr auto iar_nxp_1064_json = R"({
     "qulVersion": "2.0.0",
     "boardSdk": {
         "cmakeVar": "QUL_BOARD_SDK_DIR",
-         "label": "Board SDK for MIMXRT1064-EVK",
+        "envVar": "EVK_MIMXRT1064_SDK_PATH",
         "id": "NXP_SDK_DIR",
+        "label": "Board SDK for MIMXRT1064-EVK",
         "optional": false,
+        "setting": "EVK_MIMXRT1064_SDK_PATH",
         "type": "path",
-         "versions": ["2.11.0"],
         "versionDetection": {
             "filePattern": "*_manifest_*.xml",
-             "xmlElement": "ksdk",
+            "regex": ".*",
             "xmlAttribute": "version",
-             "regex": ".*"
+            "xmlElement": "ksdk"
         },
-         "envVar": "EVK_MIMXRT1064_SDK_PATH",
+        "versions": ["2.11.0"]
-         "setting": "EVK_MIMXRT1064_SDK_PATH"
     },
     "freeRTOS": {
-        "cmakeEntries": [
-            {
-                "envVar": "IMXRT1064_FREERTOS_DIR",
         "cmakeVar": "FREERTOS_DIR",
         "defaultValue": "$QUL_BOARD_SDK_DIR/rtos/freertos/freertos_kernel",
-                "label": "FreeRTOS Sources (IMXRT1064) ",
+        "envVar": "IMXRT1064_FREERTOS_DIR",
-                "label": "FreeRTOS SDK for MIMXRT1064-EVK",
         "id": "NXP_FREERTOS_DIR",
+        "label": "FreeRTOS SDK for MIMXRT1064-EVK",
         "optional": false,
+        "setting": "FreeRTOSSourcePackage_IMXRT1064",
         "type": "path"
-           }
-        ],
-        "envVar": "IMXRT1064_FREERTOS_DIR"
     },
     "platform": {
         "cmakeEntries": [

src/plugins/mcusupport/test/unittest.cpp

@@ -26,6 +26,7 @@
 #include "unittest.h"
 
 #include "armgcc_nxp_1050_json.h"
+#include "armgcc_nxp_1064_json.h"
 #include "armgcc_nxp_mimxrt1170_evk_freertos_json.h"
 #include "armgcc_stm32f769i_freertos_json.h"
 #include "armgcc_stm32h750b_metal_json.h"
@@ -107,14 +108,17 @@ const char armGccToolchainFilePathWithVariable[]{"$Qul_ROOT/lib/cmake/Qul/toolch
 const char armGccVersion[]{"9.3.1"};
 const char armGccNewVersion[]{"10.3.1"};
 const char msvcVersion[]{"14.29"};
-const QStringList boardSdkVersions{{"2.11.0"}};
+const char boardSdkVersion[]{"2.11.0"};
+const QString boardSdkCmakeVar{Legacy::Constants::BOARD_SDK_CMAKE_VAR};
+const char boardSdkDir[]{"/opt/Qul/2.3.0/boardDir/"};
 const char cmakeToolchainLabel[]{"CMake Toolchain File"};
 const char fallbackDir[]{"/abc/def/fallback"};
 const char freeRtosCMakeVar[]{"FREERTOS_DIR"};
-const char freeRtosDescription[]{"Freertos directory"};
 const char freeRtosEnvVar[]{"EVK_MIMXRT1170_FREERTOS_PATH"};
 const char freeRtosLabel[]{"FreeRTOS directory"};
 const char freeRtosPath[]{"/opt/freertos/default"};
+const char freeRtosNxpPathSuffix[]{"rtos/freertos/freertos_kernel"};
+const char freeRtosStmPathSuffix[]{"/Middlewares/Third_Party/FreeRTOS/Source"};
 const char freeRtosSetting[]{"Freertos"};
 const char greenhillToolchainFilePath[]{"/opt/toolchain/ghs.cmake"};
 const char greenhillToolchainFileDefaultPath[]{
@@ -273,17 +277,32 @@ void verifyTargetToolchains(const Targets &targets,
 }
 
 void verifyBoardSdk(const McuPackagePtr &boardSdk,
+                    const QString &cmakeVariable,
                     const QString &environmentVariable,
                     const QStringList &versions)
 {
     QVERIFY(boardSdk);
-    QCOMPARE(boardSdk->cmakeVariableName(), Legacy::Constants::BOARD_SDK_CMAKE_VAR);
+    QCOMPARE(boardSdk->cmakeVariableName(), cmakeVariable);
     QCOMPARE(boardSdk->environmentVariableName(), environmentVariable);
     QCOMPARE(boardSdk->settingsKey(), environmentVariable);
     QCOMPARE(boardSdk->detectionPath().toString(), empty);
     QCOMPARE(boardSdk->versions(), versions);
 }
 
+void verifyFreeRtosPackage(const McuPackagePtr &freeRtos,
+                           const QString &envVar,
+                           const FilePath &boardSdkDir,
+                           const QString &freeRtosPath,
+                           const QString &expectedSettingsKey)
+{
+    QVERIFY(freeRtos);
+    QCOMPARE(freeRtos->environmentVariableName(), envVar);
+    QCOMPARE(freeRtos->cmakeVariableName(), freeRtosCMakeVar);
+    QCOMPARE(freeRtos->settingsKey(), expectedSettingsKey);
+    QCOMPARE(freeRtos->path().cleanPath().toString(), freeRtosPath);
+    QVERIFY(freeRtos->path().toString().startsWith(boardSdkDir.cleanPath().toString()));
+}
+
 McuSupportTest::McuSupportTest()
     : targetFactory{settingsMockPtr}
     , compilerDescription{armGccLabel, armGccEnvVar, Legacy::Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, armGccLabel, armGccDirectorySetting, {}, {}, {}, {}, false}
@@ -398,8 +417,7 @@ void McuSupportTest::test_parseCmakeEntries()
 {
     const auto description{parseDescriptionJson(iar_nxp_1064_json)};
 
-    QVERIFY(!description.freeRTOS.packages.isEmpty());
+    auto &freeRtos = description.freeRTOS.package;
-    auto &freeRtos = description.freeRTOS.packages[0];
     QCOMPARE(freeRtos.envVar, nxp1064FreeRtosEnvVar);
 }
 
@@ -607,50 +625,18 @@ void McuSupportTest::test_legacy_createPackagesWithCorrespondingSettings()
     QVERIFY(settings.contains(expectedSettings));
 }
 
-void McuSupportTest::test_createFreeRtosPackageWithCorrectSetting_data()
-{
-    QTest::addColumn<QString>("freeRtosEnvVar");
-    QTest::addColumn<QString>("expectedSettingsKey");
-
-    QTest::newRow("nxp1050") << nxp1050FreeRtosEnvVar
-                             << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(
-                                    nxp1050);
-    QTest::newRow("nxp1064") << nxp1064FreeRtosEnvVar
-                             << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(
-                                    nxp1064);
-    QTest::newRow("nxp1170") << nxp1170FreeRtosEnvVar
-                             << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(
-                                    nxp1170);
-    QTest::newRow("stm32f7") << stm32f7FreeRtosEnvVar
-                             << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(
-                                    stm32f7);
-}
-
-void McuSupportTest::test_createFreeRtosPackageWithCorrectSetting()
-{
-    QFETCH(QString, freeRtosEnvVar);
-    QFETCH(QString, expectedSettingsKey);
-
-    McuPackagePtr package{
-        Legacy::createFreeRTOSSourcesPackage(settingsMockPtr, freeRtosEnvVar, FilePath{})};
-    QVERIFY(package != nullptr);
-
-    QCOMPARE(package->settingsKey(), expectedSettingsKey);
-}
-
 void McuSupportTest::test_createTargets()
 {
-    PackageDescription packageDescription{id,
+    targetDescription.freeRTOS.package = {id,
                                           nxp1064FreeRtosEnvVar,
                                           freeRtosCMakeVar,
                                           freeRtosSetting,
-                                          freeRtosDescription,
+                                          freeRtosLabel,
                                           freeRtosPath,
                                           "",
                                           {},
                                           VersionDetection{},
                                           true};
-    targetDescription.freeRTOS.packages.append(packageDescription);
     targetDescription.toolchain.id = armGcc;
 
     const auto [targets, packages]{targetFactory.createTargets(targetDescription, qtForMcuSdkPath)};
@@ -693,7 +679,7 @@ void McuSupportTest::test_createTargets()
 
 void McuSupportTest::test_createPackages()
 {
-    PackageDescription packageDescription{id,
+    targetDescription.freeRTOS.package = {id,
                                           nxp1064FreeRtosEnvVar,
                                           freeRtosCMakeVar,
                                           freeRtosLabel,
@@ -703,7 +689,6 @@ void McuSupportTest::test_createPackages()
                                           {},
                                           VersionDetection{},
                                           true};
-    targetDescription.freeRTOS.packages.append(packageDescription);
 
     const auto packages{targetFactory.createPackages(targetDescription)};
     QVERIFY(!packages.empty());
@@ -937,32 +922,39 @@ void McuSupportTest::test_addToolchainFileInfoToKit()
 void McuSupportTest::test_legacy_createBoardSdk_data()
 {
     QTest::addColumn<QString>("json");
+    QTest::addColumn<QString>("cmakeVariable");
     QTest::addColumn<QString>("environmentVariable");
     QTest::addColumn<QStringList>("versions");
 
     QTest::newRow("armgcc_nxp_1050_json")
-        << armgcc_nxp_1050_json << "EVKB_IMXRT1050_SDK_PATH" << boardSdkVersions;
+        << armgcc_nxp_1050_json << boardSdkCmakeVar << "EVKB_IMXRT1050_SDK_PATH"
-    QTest::newRow("stm32h750b") << armgcc_stm32h750b_metal_json << "STM32Cube_FW_H7_SDK_PATH"
+        << QStringList{boardSdkVersion};
-                                << QStringList{"1.5.0"};
+
-    QTest::newRow("stm32f769i") << armgcc_stm32f769i_freertos_json << "STM32Cube_FW_F7_SDK_PATH"
+    QTest::newRow("armgcc_nxp_1064_json") << armgcc_nxp_1064_json << boardSdkCmakeVar
-                                << QStringList{"1.16.0"};
+                                          << "EVK_MIMXRT1064_SDK_PATH" << QStringList{"2.11.1"};
-    QTest::newRow("stm32f469i") << iar_stm32f469i_metal_json << "STM32Cube_FW_F4_SDK_PATH"
+    QTest::newRow("stm32h750b") << armgcc_stm32h750b_metal_json << boardSdkCmakeVar
-                                << QStringList{"1.25.0"};
+                                << "STM32Cube_FW_H7_SDK_PATH" << QStringList{"1.5.0"};
-    QTest::newRow("nxp1064") << iar_nxp_1064_json << "EVK_MIMXRT1064_SDK_PATH" << boardSdkVersions;
+    QTest::newRow("stm32f769i") << armgcc_stm32f769i_freertos_json << boardSdkCmakeVar
+                                << "STM32Cube_FW_F7_SDK_PATH" << QStringList{"1.16.0"};
+    QTest::newRow("stm32f469i") << iar_stm32f469i_metal_json << boardSdkCmakeVar
+                                << "STM32Cube_FW_F4_SDK_PATH" << QStringList{"1.25.0"};
+    QTest::newRow("nxp1064") << iar_nxp_1064_json << boardSdkCmakeVar << "EVK_MIMXRT1064_SDK_PATH"
+                             << QStringList{boardSdkVersion};
     QTest::newRow("ghs_rh850_d1m1a_baremetal_json")
-        << ghs_rh850_d1m1a_baremetal_json << "RGL_DIR" << QStringList{"2.0.0a"};
+        << ghs_rh850_d1m1a_baremetal_json << boardSdkCmakeVar << "RGL_DIR" << QStringList{"2.0.0a"};
 }
 
 void McuSupportTest::test_legacy_createBoardSdk()
 {
     QFETCH(QString, json);
+    QFETCH(QString, cmakeVariable);
     QFETCH(QString, environmentVariable);
     QFETCH(QStringList, versions);
 
     McuTargetDescription target{parseDescriptionJson(json.toLocal8Bit())};
     McuPackagePtr boardSdk{Legacy::createBoardSdkPackage(settingsMockPtr, target)};
 
-    verifyBoardSdk(boardSdk, environmentVariable, versions);
+    verifyBoardSdk(boardSdk, cmakeVariable, environmentVariable, versions);
 }
 
 void McuSupportTest::test_createBoardSdk_data()
@@ -973,6 +965,7 @@ void McuSupportTest::test_createBoardSdk_data()
 void McuSupportTest::test_createBoardSdk()
 {
     QFETCH(QString, json);
+    QFETCH(QString, cmakeVariable);
     QFETCH(QString, environmentVariable);
     QFETCH(QStringList, versions);
 
@@ -980,7 +973,109 @@ void McuSupportTest::test_createBoardSdk()
 
     McuPackagePtr boardSdk{targetFactory.createPackage(target.boardSdk)};
 
-    verifyBoardSdk(boardSdk, environmentVariable, versions);
+    verifyBoardSdk(boardSdk, cmakeVariable, environmentVariable, versions);
+}
+
+void McuSupportTest::test_legacy_createFreeRtosPackage_data()
+{
+    QTest::addColumn<QString>("json");
+    QTest::addColumn<QStringList>("versions");
+    QTest::addColumn<QString>("expectedSettingsKey");
+    QTest::addColumn<FilePath>("expectedPath");
+
+    QTest::newRow("armgcc_nxp_1050_json")
+        << armgcc_nxp_1050_json << QStringList{boardSdkVersion}
+        << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(nxp1050)
+        << FilePath::fromUserInput(boardSdkDir) / freeRtosNxpPathSuffix;
+    QTest::newRow("armgcc_nxp_1064_json")
+        << armgcc_nxp_1064_json << QStringList{boardSdkVersion}
+        << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(nxp1064)
+        << FilePath::fromUserInput(boardSdkDir) / freeRtosNxpPathSuffix;
+    QTest::newRow("iar_nxp_1064_json")
+        << iar_nxp_1064_json << QStringList{boardSdkVersion}
+        << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(nxp1064)
+        << FilePath::fromUserInput(boardSdkDir) / freeRtosNxpPathSuffix;
+    QTest::newRow("armgcc_stm32f769i_freertos_json")
+        << armgcc_stm32f769i_freertos_json << QStringList{"1.16.0"}
+        << QString{Legacy::Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(stm32f7)
+        << FilePath::fromUserInput(boardSdkDir) / freeRtosStmPathSuffix;
+}
+
+void McuSupportTest::test_legacy_createFreeRtosPackage()
+{
+    QFETCH(QString, json);
+    QFETCH(QStringList, versions);
+    QFETCH(QString, expectedSettingsKey);
+    QFETCH(FilePath, expectedPath);
+
+    McuTargetDescription targetDescription{parseDescriptionJson(json.toLocal8Bit())};
+
+    EXPECT_CALL(*settingsMockPtr, getPath(expectedSettingsKey, _, _))
+        .WillRepeatedly(Return(FilePath::fromString(expectedPath.toUserOutput())));
+    McuPackagePtr freeRtos{Legacy::createFreeRTOSSourcesPackage(settingsMockPtr,
+                                                                targetDescription.freeRTOS.envVar,
+                                                                FilePath{})};
+
+    verifyFreeRtosPackage(freeRtos,
+                          targetDescription.freeRTOS.envVar,
+                          boardSdkDir,
+                          expectedPath.toUserOutput(),
+                          expectedSettingsKey);
+}
+
+void McuSupportTest::test_createFreeRtosPackage_data()
+{
+    test_legacy_createFreeRtosPackage_data();
+}
+
+void McuSupportTest::test_createFreeRtosPackage()
+{
+    QFETCH(QString, json);
+    QFETCH(QStringList, versions);
+    QFETCH(QString, expectedSettingsKey);
+    QFETCH(FilePath, expectedPath);
+
+    McuTargetDescription targetDescription{parseDescriptionJson(json.toLocal8Bit())};
+
+    EXPECT_CALL(*settingsMockPtr, getPath(targetDescription.boardSdk.envVar, _, _))
+        .WillRepeatedly(Return(FilePath::fromString(boardSdkDir)));
+
+    auto [targets, packages] = targetFactory.createTargets(targetDescription, qtForMcuSdkPath);
+
+    auto freeRtos = findOrDefault(packages, [](const McuPackagePtr &pkg) {
+        return (pkg->cmakeVariableName() == freeRtosCMakeVar);
+    });
+
+    verifyFreeRtosPackage(freeRtos,
+                          targetDescription.freeRTOS.envVar,
+                          boardSdkDir,
+                          expectedPath.toUserOutput(),
+                          expectedSettingsKey);
+}
+
+void McuSupportTest::test_legacy_doNOTcreateFreeRtosPackageForMetalVariants_data()
+
+{
+    QTest::addColumn<QString>("json");
+    QTest::newRow("iar_stm32f469i_metal_json") << iar_stm32f469i_metal_json;
+    QTest::newRow("armgcc_stm32h750b_metal_json") << armgcc_stm32h750b_metal_json;
+    QTest::newRow("ghs_rh850_d1m1a_baremetal_json") << ghs_rh850_d1m1a_baremetal_json;
+    QTest::newRow("gcc_desktop_json") << gcc_desktop_json;
+}
+
+void McuSupportTest::test_legacy_doNOTcreateFreeRtosPackageForMetalVariants()
+{
+    QFETCH(QString, json);
+
+    McuTargetDescription targetDescription{parseDescriptionJson(json.toLocal8Bit())};
+    QCOMPARE(targetDescription.freeRTOS.package.cmakeVar, "");
+
+    auto [targets, packages] = targetFactory.createTargets(targetDescription, qtForMcuSdkPath);
+
+    auto freeRtos = findOrDefault(packages, [](const McuPackagePtr &pkg) {
+        return (pkg->cmakeVariableName() == freeRtosCMakeVar);
+    });
+    QCOMPARE(freeRtos, nullptr);
 }
 
 void McuSupportTest::test_legacy_createQtMCUsPackage()

src/plugins/mcusupport/test/unittest.h

@@ -65,8 +65,6 @@ private slots:
     void test_createTargetWithToolchainPackages();
     void test_legacy_createQtMCUsPackage();
 
-    void test_createFreeRtosPackageWithCorrectSetting_data();
-    void test_createFreeRtosPackageWithCorrectSetting();
     void test_createTargets();
     void test_createPackages();
     void test_legacy_createIarToolchain();
@@ -106,6 +104,13 @@ private slots:
     void test_createBoardSdk_data();
     void test_createBoardSdk();
 
+    void test_legacy_doNOTcreateFreeRtosPackageForMetalVariants_data();
+    void test_legacy_doNOTcreateFreeRtosPackageForMetalVariants();
+    void test_legacy_createFreeRtosPackage_data();
+    void test_legacy_createFreeRtosPackage();
+    void test_createFreeRtosPackage_data();
+    void test_createFreeRtosPackage();
+
     void test_resolveEnvironmentVariablesInDefaultPath();
     void test_resolveCmakeVariablesInDefaultPath();