McuSupport: 3rd party packages creation tests

Change-Id: I0f9ed6c49b28007c617627525fc081ae9152e3f1
Reviewed-by: hjk <hjk@qt.io>

src/plugins/mcusupport/mcupackage.cpp

@@ -37,15 +37,13 @@ McuPackage::McuPackage(const SettingsHandler::Ptr &settingsHandler,
                        const QStringList &versions,
                        const QString &downloadUrl,
                        const McuPackageVersionDetector *versionDetector,
-                       const bool addToSystemPath,
+                       const bool addToSystemPath)
-                       const FilePath &relativePathModifier)
     : settingsHandler(settingsHandler)
     , m_label(label)
     , m_defaultPath(settingsHandler->getPath(settingsKey, QSettings::SystemScope, defaultPath))
     , m_detectionPath(detectionPath)
     , m_settingsKey(settingsKey)
     , m_versionDetector(versionDetector)
-    , m_relativePathModifier(relativePathModifier)
     , m_versions(versions)
     , m_cmakeVariableName(cmakeVarName)
     , m_environmentVariableName(envVarName)
@@ -100,7 +98,7 @@ FilePath McuPackage::basePath() const
 
 FilePath McuPackage::path() const
 {
-    return (basePath() / m_relativePathModifier.path()).cleanPath();
+    return basePath().cleanPath();
 }
 
 FilePath McuPackage::defaultPath() const

src/plugins/mcusupport/mcupackage.h

@@ -40,8 +40,7 @@ public:
                const QStringList &versions = {},
                const QString &downloadUrl = {},
                const McuPackageVersionDetector *versionDetector = nullptr,
-               const bool addToPath = false,
+               const bool addToPath = false);
-               const Utils::FilePath &relativePathModifier = Utils::FilePath());
 
     ~McuPackage() override = default;
 
@@ -85,7 +84,6 @@ private:
     QScopedPointer<const McuPackageVersionDetector> m_versionDetector;
 
     Utils::FilePath m_path;
-    Utils::FilePath m_relativePathModifier; // relative path to m_path to be returned by path()
     QString m_detectedVersion;
     QStringList m_versions;
     const QString m_cmakeVariableName;

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -361,15 +361,12 @@ McuPackagePtr createStm32CubeProgrammerPackage(const SettingsHandler::Ptr &setti
 {
     FilePath defaultPath;
     const QString cubePath = "STMicroelectronics/STM32Cube/STM32CubeProgrammer";
-    if (HostOsInfo::isWindowsHost()) {
+    if (HostOsInfo::isWindowsHost())
-        const FilePath programPath = findInProgramFiles(cubePath);
+        defaultPath = findInProgramFiles(cubePath) / "bin";
-        if (!programPath.isEmpty())
+    else
-            defaultPath = programPath;
+        defaultPath = FileUtils::homePath() / cubePath / "bin";
-    } else {
+    if (!defaultPath.exists())
-        const FilePath programPath = FileUtils::homePath() / cubePath;
+        FilePath defaultPath = {};
-        if (programPath.exists())
-            defaultPath = programPath;
-    }
 
     const FilePath detectionPath = FilePath::fromUserInput(
         QLatin1String(Utils::HostOsInfo::isWindowsHost() ? "/bin/STM32_Programmer_CLI.exe"
@@ -386,8 +383,7 @@ McuPackagePtr createStm32CubeProgrammerPackage(const SettingsHandler::Ptr &setti
                        {},                                                           // versions
                        "https://www.st.com/en/development-tools/stm32cubeprog.html", // download url
                        nullptr, // version detector
-                       true,    // add to path
+                       true     // add to path
-                       "/bin"   // relative path modifier
                        )};
 }
 

src/plugins/mcusupport/test/armgcc_stm32f469i_discovery_baremetal_json.h

@@ -18,6 +18,7 @@ constexpr auto armgcc_stm32f469i_discovery_baremetal_json = R"(
                 "id": "STM32CubeProgrammer_PATH",
                 "label": "STM32CubeProgrammer",
                 "type": "path",
+                "setting": "Stm32CubeProgrammer",
                 "defaultValue": {
                     "windows": "%{Env:PROGRAMSANDFILES}/STMicroelectronics/STM32Cube/STM32CubeProgrammer/",
                     "unix": "%{Env:HOME}/STMicroelectronics/STM32Cube/STM32CubeProgrammer/"

src/plugins/mcusupport/test/ghs_rh850_d1m1a_baremetal_json.h

@@ -17,14 +17,15 @@ constexpr auto ghs_rh850_d1m1a_baremetal_json = R"(
             {
                 "id": "FlashProgrammer_path",
                 "setting": "FlashProgrammerPath",
-                "label": "Path to Renesas Flash Programmer",
+                "label": "Renesas Flash Programmer",
                 "type": "path",
+                "setting": "RenesasFlashProgrammer",
                 "cmakeVar": "RENESAS_FLASH_PROGRAMMER_PATH",
                 "defaultValue": {
                     "windows": "%{Env:PROGRAMSANDFILES}/Renesas Electronics/Programming Tools/Renesas Flash Programmer V3.09",
                     "unix": "%{Env:HOME}"
                 },
-                "envVar": "RenesasFlashProgrammer_PATH",
+                "envVar": "RENESAS_FLASH_PROGRAMMER_PATH",
                 "optional": true,
                 "addToSystemPath": true
             }

src/plugins/mcusupport/test/iar_stm32f469i_discovery_baremetal_json.h

@@ -18,6 +18,7 @@ constexpr auto iar_stm32f469i_discovery_baremetal_json = R"(
                 "id": "STM32CubeProgrammer_PATH",
                 "label": "STM32CubeProgrammer",
                 "type": "path",
+                "setting": "Stm32CubeProgrammer",
                 "defaultValue": {
                     "windows": "%{Env:PROGRAMSANDFILES}/STMicroelectronics/STM32Cube/STM32CubeProgrammer/",
                     "unix": "%{Env:HOME}/STMicroelectronics/STM32Cube/STM32CubeProgrammer/"

src/plugins/mcusupport/test/unittest.cpp

@@ -3,6 +3,7 @@
 
 #include "unittest.h"
 
+#include "armgcc_ek_ra6m3g_baremetal_json.h"
 #include "armgcc_mimxrt1050_evk_freertos_json.h"
 #include "armgcc_mimxrt1064_evk_freertos_json.h"
 #include "armgcc_mimxrt1170_evk_freertos_json.h"
@@ -11,6 +12,7 @@
 #include "errors_json.h"
 #include "gcc_desktop_json.h"
 #include "ghs_rh850_d1m1a_baremetal_json.h"
+#include "ghs_tviic2d6m_baremetal_json.h"
 #include "iar_mimxrt1064_evk_freertos_json.h"
 #include "iar_stm32f469i_discovery_baremetal_json.h"
 #include "msvc_desktop_json.h"
@@ -123,6 +125,43 @@ const char vendor[]{"target_vendor"};
 const QString settingsPrefix = QLatin1String(Constants::SETTINGS_GROUP) + '/'
                                + QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX);
 
+const char defaultToolPath[]{"/opt/biz/foo"};
+const char xpressoIdePath[]{"/usr/local/mcuxpressoide"};
+const char xpressoIdeLabel[]{"MCUXpresso IDE"};
+const char xpressoIdeSetting[]{"MCUXpressoIDE"};
+const char xpressoIdeCmakeVar[]{"MCUXPRESSO_IDE_PATH"};
+const char xpressoIdeEnvVar[]{"MCUXpressoIDE_PATH"};
+const char xpressoIdeDetectionPath[]{"ide/binaries/crt_emu_cm_redlink"};
+
+const char stmCubeProgrammerSetting[]{"Stm32CubeProgrammer"};
+const char stmCubeProgrammerLabel[]{"STM32CubeProgrammer"};
+const QString stmCubeProgrammerPath{QString{defaultToolPath} + "/bin"};
+const QString stmCubeProgrammerDetectionPath{"/bin/STM32_Programmer.sh"};
+
+const char renesasProgrammerSetting[]{"RenesasFlashProgrammer"};
+const char renesasProgrammerCmakeVar[]{"RENESAS_FLASH_PROGRAMMER_PATH"};
+const QString renesasProgrammerEnvVar{renesasProgrammerCmakeVar};
+const char renesasProgrammerLabel[]{"Renesas Flash Programmer"};
+const char renesasProgrammerDetectionPath[]{"rfp-cli"};
+
+const char renesasE2StudioCmakeVar[]{"EK_RA6M3G_E2_PROJECT_PATH"};
+const char renesasE2StudioDefaultPath[]{"%{Env:HOME}/e2_studio/workspace"};
+const QString renesasE2StudioPath{(FileUtils::homePath() / "/e2_studio/workspace").toUserOutput()};
+const char renesasE2StudioLabel[]{"Path to project for Renesas e2 Studio"};
+const char renesasE2StudioSetting[]{"RenesasE2StudioPath"};
+
+const char cypressProgrammerSetting[]{"CypressAutoFlashUtil"};
+const char cypressProgrammerCmakeVar[]{"INFINEON_AUTO_FLASH_UTILITY_DIR"};
+const char cypressProgrammerEnvVar[]{"CYPRESS_AUTO_FLASH_UTILITY_DIR"};
+const char cypressProgrammerLabel[]{"Cypress Auto Flash Utility"};
+const char cypressProgrammerDetectionPath[]{"/bin/openocd"};
+
+const char jlinkPath[]{"/opt/SEGGER/JLink"};
+const char jlinkSetting[]{"JLinkPath"};
+const char jlinkCmakeVar[]{"JLINK_PATH"};
+const char jlinkEnvVar[]{"JLINK_PATH"};
+const char jlinkLabel[]{"Path to SEGGER J-Link"};
+
 const QString unsupportedToolchainFilePath = QString{qtForMcuSdkPath}
                                              + "/lib/cmake/Qul/toolchain/unsupported.cmake";
 
@@ -282,6 +321,7 @@ void verifyPackage(const McuPackagePtr &package,
                    const QString &cmakeVar,
                    const QString &envVar,
                    const QString &label,
+                   const QString &detectionPath,
                    const QStringList &versions)
 {
     QVERIFY(package);
@@ -290,6 +330,7 @@ void verifyPackage(const McuPackagePtr &package,
     QCOMPARE(package->cmakeVariableName(), cmakeVar);
     QCOMPARE(package->environmentVariableName(), envVar);
     QCOMPARE(package->label(), label);
+    QCOMPARE(package->detectionPath().toString(), detectionPath);
     QCOMPARE(package->settingsKey(), setting);
     QCOMPARE(package->versions(), versions);
 }
@@ -928,11 +969,12 @@ void McuSupportTest::test_createTargetWithToolchainPackages()
 
     verifyPackage(qtForMCUsSDK,
                   qtForMcuSdkPath,
-                  {}, // qtForMcuSdkPath
+                  {},
                   Constants::SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK,
                   QUL_CMAKE_VAR,
                   QUL_ENV_VAR,
                   QUL_LABEL,
+                  {},
                   {});
 
     verifyTargetToolchains(targets,
@@ -1372,76 +1414,164 @@ void McuSupportTest::test_resolveCmakeVariablesInDefaultPath()
 
 void McuSupportTest::test_legacy_createThirdPartyPackage_data()
 {
-    const QString defaultToolPath{"/opt/biz/foo"};
-
-    const char xpressoIdeSetting[]{"MCUXpressoIDE"};
-    const char xpressoIdeCmakeVar[]{"MCUXPRESSO_IDE_PATH"};
-    const char xpressoIdeEnvVar[]{"MCUXpressoIDE_PATH"};
-
-    const char stmCubeProgrammerSetting[]{"Stm32CubeProgrammer"};
-    const QString stmCubeProgrammerPath{defaultToolPath + "/bin"};
-
-    const char renesasProgrammerSetting[]{"RenesasFlashProgrammer"};
-    const char renesasProgrammerCmakeVar[]{"RENESAS_FLASH_PROGRAMMER_PATH"};
-    const QString renesasProgrammerEnvVar{renesasProgrammerCmakeVar};
-
-    const char cypressProgrammerSetting[]{"CypressAutoFlashUtil"};
-    const char cypressProgrammerCmakeVar[]{"INFINEON_AUTO_FLASH_UTILITY_DIR"};
-    const char cypressProgrammerEnvVar[]{"CYPRESS_AUTO_FLASH_UTILITY_DIR"};
-
     QTest::addColumn<PackageCreator>("creator");
+    QTest::addColumn<QString>("json");
     QTest::addColumn<QString>("path");
     QTest::addColumn<QString>("defaultPath");
     QTest::addColumn<QString>("setting");
     QTest::addColumn<QString>("cmakeVar");
     QTest::addColumn<QString>("envVar");
+    QTest::addColumn<QString>("label");
+    QTest::addColumn<QString>("detectionPath");
 
-    QTest::newRow("mcuXpresso") << PackageCreator{[this]() {
+    QTest::newRow("armgcc_mimxrt1050_evk_freertos_json mcuXpresso")
-        return Legacy::createMcuXpressoIdePackage(settingsMockPtr);
+        << PackageCreator{[this]() { return Legacy::createMcuXpressoIdePackage(settingsMockPtr); }}
-    }} << defaultToolPath << defaultToolPath
+        << armgcc_mimxrt1050_evk_freertos_json << xpressoIdePath << xpressoIdePath
-                                << xpressoIdeSetting << xpressoIdeCmakeVar << xpressoIdeEnvVar;
+        << xpressoIdeSetting << xpressoIdeCmakeVar << xpressoIdeEnvVar << xpressoIdeLabel
-    QTest::newRow("stmCubeProgrammer") << PackageCreator{[this]() {
+        << xpressoIdeDetectionPath;
+
+    QTest::newRow("armgcc_mimxrt1064_evk_freertos_json mcuXpresso")
+        << PackageCreator{[this]() { return Legacy::createMcuXpressoIdePackage(settingsMockPtr); }}
+        << armgcc_mimxrt1064_evk_freertos_json << xpressoIdePath << xpressoIdePath
+        << xpressoIdeSetting << xpressoIdeCmakeVar << xpressoIdeEnvVar << xpressoIdeLabel
+        << xpressoIdeDetectionPath;
+
+    QTest::newRow("armgcc_mimxrt1170_evk_freertos_json mcuXpresso")
+        << PackageCreator{[this]() { return Legacy::createMcuXpressoIdePackage(settingsMockPtr); }}
+        << armgcc_mimxrt1170_evk_freertos_json << xpressoIdePath << xpressoIdePath
+        << xpressoIdeSetting << xpressoIdeCmakeVar << xpressoIdeEnvVar << xpressoIdeLabel
+        << xpressoIdeDetectionPath;
+
+    QTest::newRow("armgcc_stm32h750b_discovery_baremetal_json stmCubeProgrammer")
+        << PackageCreator{[this]() {
                return Legacy::createStm32CubeProgrammerPackage(settingsMockPtr);
-    }} << stmCubeProgrammerPath << defaultToolPath
+           }}
-                                       << stmCubeProgrammerSetting << empty << empty;
+        << armgcc_stm32h750b_discovery_baremetal_json << stmCubeProgrammerPath
-
+        << stmCubeProgrammerPath << stmCubeProgrammerSetting << empty << empty
-    QTest::newRow("renesasProgrammer") << PackageCreator{[this]() {
+        << stmCubeProgrammerLabel << stmCubeProgrammerDetectionPath;
+    QTest::newRow("armgcc_stm32f769i_discovery_freertos_json stmCubeProgrammer")
+        << PackageCreator{[this]() {
+               return Legacy::createStm32CubeProgrammerPackage(settingsMockPtr);
+           }}
+        << armgcc_stm32f769i_discovery_freertos_json << stmCubeProgrammerPath
+        << stmCubeProgrammerPath << stmCubeProgrammerSetting << empty << empty
+        << stmCubeProgrammerLabel << stmCubeProgrammerDetectionPath;
+    QTest::newRow("ghs_rh850_d1m1a_baremetal_json renesasProgrammer")
+        << PackageCreator{[this]() {
                return Legacy::createRenesasProgrammerPackage(settingsMockPtr);
-    }} << defaultToolPath << defaultToolPath
+           }}
-                                       << renesasProgrammerSetting << renesasProgrammerCmakeVar
+        << ghs_rh850_d1m1a_baremetal_json << defaultToolPath << defaultToolPath
-                                       << renesasProgrammerEnvVar;
+        << renesasProgrammerSetting << renesasProgrammerCmakeVar << renesasProgrammerEnvVar
-
+        << renesasProgrammerLabel << renesasProgrammerDetectionPath;
-    QTest::newRow("cypressProgrammer") << PackageCreator{[this]() {
-        return Legacy::createCypressProgrammerPackage(settingsMockPtr);
-    }} << defaultToolPath << defaultToolPath
-                                       << cypressProgrammerSetting << cypressProgrammerCmakeVar
-                                       << cypressProgrammerEnvVar;
 }
 
 void McuSupportTest::test_legacy_createThirdPartyPackage()
 {
     QFETCH(PackageCreator, creator);
+    QFETCH(QString, json);
     QFETCH(QString, path);
     QFETCH(QString, defaultPath);
     QFETCH(QString, setting);
     QFETCH(QString, cmakeVar);
     QFETCH(QString, envVar);
-
+    QFETCH(QString, label);
-    if (!envVar.isEmpty())
+    QFETCH(QString, detectionPath);
-        QVERIFY(qputenv(envVar.toLocal8Bit(), defaultPath.toLocal8Bit()));
 
     EXPECT_CALL(*settingsMockPtr, getPath(QString{setting}, _, _))
         .Times(2)
         .WillRepeatedly(Return(FilePath::fromUserInput(defaultPath)));
 
-    McuPackagePtr thirdPartyPacakge{creator()};
+    McuPackagePtr thirdPartyPackage{creator()};
-    QVERIFY(thirdPartyPacakge);
+    verifyPackage(thirdPartyPackage,
-    QCOMPARE(thirdPartyPacakge->settingsKey(), setting);
+                  path,
-    QCOMPARE(thirdPartyPacakge->environmentVariableName(), envVar);
+                  defaultPath,
-    QCOMPARE(thirdPartyPacakge->path().toString(), path);
+                  setting,
+                  cmakeVar,
+                  envVar,
+                  label,
+                  detectionPath,
+                  {});
+}
 
-    if (!envVar.isEmpty())
+void McuSupportTest::test_createThirdPartyPackage_data()
-        QVERIFY(qunsetenv(envVar.toLocal8Bit()));
+{
+    test_legacy_createThirdPartyPackage_data();
+}
+
+void McuSupportTest::test_createThirdPartyPackage()
+{
+    QFETCH(QString, json);
+    QFETCH(QString, path);
+    QFETCH(QString, defaultPath);
+    QFETCH(QString, setting);
+    QFETCH(QString, cmakeVar);
+    QFETCH(QString, envVar);
+    QFETCH(QString, label);
+
+    McuTargetDescription targetDescription{parseDescriptionJson(json.toLocal8Bit())};
+
+    EXPECT_CALL(*settingsMockPtr, getPath(QString{setting}, QSettings::SystemScope, _))
+        .Times(testing::AtMost(1))
+        .WillOnce(Return(FilePath::fromUserInput(defaultPath)));
+
+    EXPECT_CALL(*settingsMockPtr, getPath(QString{setting}, QSettings::UserScope, _))
+        .Times(testing::AtMost(1))
+        .WillOnce(Return(FilePath::fromUserInput(path)));
+
+    auto [targets, packages] = targetFactory.createTargets(targetDescription, sdkPackagePtr);
+
+    auto thirdPartyPackage = findOrDefault(packages, [&setting](const McuPackagePtr &pkg) {
+        return (pkg->settingsKey() == setting);
+    });
+
+    verifyPackage(thirdPartyPackage, path, defaultPath, setting, cmakeVar, envVar, label, {}, {});
+}
+
+void McuSupportTest::test_legacy_createCypressProgrammer3rdPartyPackage()
+{
+    EXPECT_CALL(*settingsMockPtr, getPath(QString{cypressProgrammerSetting}, _, _))
+        .Times(2)
+        .WillRepeatedly(Return(FilePath::fromUserInput(defaultToolPath)));
+
+    McuPackagePtr thirdPartyPackage{Legacy::createCypressProgrammerPackage(settingsMockPtr)};
+    verifyPackage(thirdPartyPackage,
+                  defaultToolPath,
+                  defaultToolPath,
+                  cypressProgrammerSetting,
+                  cypressProgrammerCmakeVar,
+                  cypressProgrammerEnvVar,
+                  cypressProgrammerLabel,
+                  cypressProgrammerDetectionPath,
+                  {});
+}
+
+void McuSupportTest::test_createJLink3rdPartyPackage()
+{
+    McuTargetDescription targetDescription{parseDescriptionJson(armgcc_ek_ra6m3g_baremetal_json)};
+
+    EXPECT_CALL(*settingsMockPtr, getPath(QString{jlinkSetting}, QSettings::SystemScope, _))
+        .Times(testing::AtMost(1))
+        .WillOnce(Return(FilePath::fromUserInput(jlinkPath)));
+
+    EXPECT_CALL(*settingsMockPtr, getPath(QString{jlinkSetting}, QSettings::UserScope, _))
+        .Times(testing::AtMost(1))
+        .WillOnce(Return(FilePath::fromUserInput(jlinkPath)));
+
+    auto [targets, packages] = targetFactory.createTargets(targetDescription, sdkPackagePtr);
+
+    auto thirdPartyPackage = findOrDefault(packages, [](const McuPackagePtr &pkg) {
+        return (pkg->settingsKey() == jlinkSetting);
+    });
+
+    verifyPackage(thirdPartyPackage,
+                  jlinkPath,
+                  jlinkPath,
+                  jlinkSetting,
+                  jlinkCmakeVar,
+                  jlinkEnvVar,
+                  jlinkLabel,
+                  {},
+                  {});
 }
 
 void McuSupportTest::test_defaultValueForEachOperationSystem()

src/plugins/mcusupport/test/unittest.h

@@ -94,6 +94,10 @@ private slots:
 
     void test_legacy_createThirdPartyPackage_data();
     void test_legacy_createThirdPartyPackage();
+    void test_createThirdPartyPackage_data();
+    void test_createThirdPartyPackage();
+    void test_legacy_createCypressProgrammer3rdPartyPackage();
+    void test_createJLink3rdPartyPackage();
 
     void test_defaultValueForEachOperationSystem();
     void test_addToSystemPathFlag();