feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

McuSupport: create toolchain from JSON file

Browse Source 
Most of the code is unit tests for toolchain creation.

Change-Id: I955ba49db38acf6f9e35d366280b710ea0466655
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
This commit is contained in:
Piotr Mućko
2022-03-23 13:24:02 +01:00
parent 365a05640b
commit 80c87ddceb
18 changed files with 523 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/plugins/mcusupport/mcuabstractpackage.h
View File

@@ -48,8 +48,8 @@ public:
virtual ~McuAbstractPackage() = default;
virtual QString label() const = 0;
virtual const QString &cmakeVariableName() const = 0;
virtual const QString &environmentVariableName() const = 0;
virtual QString cmakeVariableName() const = 0;
virtual QString environmentVariableName() const = 0;
virtual bool isAddToSystemPath() const = 0;
virtual void setVersions(const QStringList &) = 0;

27
src/plugins/mcusupport/mcupackage.cpp
View File

@@ -25,20 +25,20 @@
#include "mcupackage.h"
#include "mcusupportconstants.h"
#include "mcusupportversiondetection.h"
#include "mcusupportsdk.h"
#include "mcusupportversiondetection.h"
#include <baremetal/baremetalconstants.h>
#include <coreplugin/icore.h>
#include <debugger/debuggeritem.h>
#include <debugger/debuggeritemmanager.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/toolchain.h>
#include <projectexplorer/toolchainmanager.h>
#include <utils/algorithm.h>
#include <utils/infolabel.h>
#include <utils/pathchooser.h>
#include <utils/utilsicons.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/toolchain.h>
#include <projectexplorer/toolchainmanager.h>
#include <debugger/debuggeritem.h>
#include <debugger/debuggeritemmanager.h>
#include <QDesktopServices>
#include <QGridLayout>
@@ -83,12 +83,12 @@ QString McuPackage::settingsKey() const
return m_settingsKey;
}
const QString &McuPackage::cmakeVariableName() const
QString McuPackage::cmakeVariableName() const
{
return m_cmakeVariableName;
}
const QString &McuPackage::environmentVariableName() const
QString McuPackage::environmentVariableName() const
{
return m_environmentVariableName;
}
@@ -285,7 +285,14 @@ McuToolChainPackage::McuToolChainPackage(const QString &label,
const QString &cmakeVarName,
const QString &envVarName,
const McuPackageVersionDetector *versionDetector)
: McuPackage(label, defaultPath, detectionPath, settingsKey, cmakeVarName, envVarName, {}, versionDetector)
: McuPackage(label,
defaultPath,
detectionPath,
settingsKey,
cmakeVarName,
envVarName,
{},
versionDetector)
, m_type(type)
{}
@@ -398,7 +405,7 @@ ToolChain *McuToolChainPackage::toolChain(Id language) const
const QLatin1String compilerName(
language == ProjectExplorer::Constants::C_LANGUAGE_ID ? "gcc" : "g++");
const QString comp = QLatin1String(m_type == ToolChainType::ArmGcc ? "/bin/arm-none-eabi-%1"
: "/bar/foo-keil-%1")
: "/bar/foo-keil-%1")
.arg(compilerName);
const FilePath compiler = path().pathAppended(comp).withExecutableSuffix();

4
src/plugins/mcusupport/mcupackage.h
View File

@@ -67,8 +67,8 @@ public:
~McuPackage() override = default;
QString label() const override;
const QString &cmakeVariableName() const override;
const QString &environmentVariableName() const override;
QString cmakeVariableName() const override;
QString environmentVariableName() const override;
bool isAddToSystemPath() const override;
void setVersions(const QStringList &versions) override;

34
src/plugins/mcusupport/mcusupportconstants.h
View File

@@ -28,24 +28,26 @@
namespace McuSupport {
namespace Constants {
const char DEVICE_TYPE[] = "McuSupport.DeviceType";
const char DEVICE_ID[] = "McuSupport.Device";
const char RUNCONFIGURATION[] = "McuSupport.RunConfiguration";
const char SETTINGS_ID[] = "CC.McuSupport.Configuration";
const char DEVICE_TYPE[]{"McuSupport.DeviceType"};
const char DEVICE_ID[]{"McuSupport.Device"};
const char RUNCONFIGURATION[]{"McuSupport.RunConfiguration"};
const char SETTINGS_ID[]{"CC.McuSupport.Configuration"};
const char KIT_MCUTARGET_VENDOR_KEY[] = "McuSupport.McuTargetVendor";
const char KIT_MCUTARGET_MODEL_KEY[] = "McuSupport.McuTargetModel";
const char KIT_MCUTARGET_SDKVERSION_KEY[] = "McuSupport.McuTargetSdkVersion";
const char KIT_MCUTARGET_KITVERSION_KEY[] = "McuSupport.McuTargetKitVersion";
const char KIT_MCUTARGET_COLORDEPTH_KEY[] = "McuSupport.McuTargetColorDepth";
const char KIT_MCUTARGET_OS_KEY[] = "McuSupport.McuTargetOs";
const char KIT_MCUTARGET_TOOCHAIN_KEY[] = "McuSupport.McuTargetToolchain";
const char KIT_MCUTARGET_VENDOR_KEY[]{"McuSupport.McuTargetVendor"};
const char KIT_MCUTARGET_MODEL_KEY[]{"McuSupport.McuTargetModel"};
const char KIT_MCUTARGET_SDKVERSION_KEY[]{"McuSupport.McuTargetSdkVersion"};
const char KIT_MCUTARGET_KITVERSION_KEY[]{"McuSupport.McuTargetKitVersion"};
const char KIT_MCUTARGET_COLORDEPTH_KEY[]{"McuSupport.McuTargetColorDepth"};
const char KIT_MCUTARGET_OS_KEY[]{"McuSupport.McuTargetOs"};
const char KIT_MCUTARGET_TOOCHAIN_KEY[]{"McuSupport.McuTargetToolchain"};
const char SETTINGS_GROUP[] = "McuSupport";
const char SETTINGS_KEY_PACKAGE_PREFIX[] = "Package_";
const char SETTINGS_KEY_FREERTOS_PREFIX[] = "FreeRTOSSourcePackage_";
const char SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK[] = "QtForMCUsSdk"; // Key known by SDK installer
const char SETTINGS_KEY_AUTOMATIC_KIT_CREATION[] = "AutomaticKitCreation";
const char SETTINGS_GROUP[]{"McuSupport"};
const char SETTINGS_KEY_PACKAGE_PREFIX[]{"Package_"};
const char SETTINGS_KEY_FREERTOS_PREFIX[]{"FreeRTOSSourcePackage_"};
const char SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK[]{"QtForMCUsSdk"}; // Key known by SDK installer
const char SETTINGS_KEY_AUTOMATIC_KIT_CREATION[]{"AutomaticKitCreation"};
const char TOOLCHAIN_DIR_CMAKE_VARIABLE[]{"QUL_TARGET_TOOLCHAIN_DIR"};
const char TOOLCHAIN_FILE_CMAKE_VARIABLE[]{"CMAKE_TOOLCHAIN_FILE"};
} // namespace Constants
} // namespace McuSupport

37
src/plugins/mcusupport/mcusupportsdk.cpp
View File

@@ -62,7 +62,6 @@ namespace Sdk {
namespace {
const char CMAKE_ENTRIES[]{"cmakeEntries"};
const char ID[]{"id"};
} // namespace
static FilePath findInProgramFiles(const QString &folder)
@@ -171,17 +170,17 @@ McuToolChainPackage *createUnsupportedToolChainPackage()
return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported);
}
static McuToolChainPackage *createMsvcToolChainPackage()
McuToolChainPackage *createMsvcToolChainPackage()
{
return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::MSVC);
}
static McuToolChainPackage *createGccToolChainPackage()
McuToolChainPackage *createGccToolChainPackage()
{
return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::GCC);
}
static McuToolChainPackage *createArmGccToolchainPackage()
McuToolChainPackage *createArmGccToolchainPackage()
{
const char envVar[] = "ARMGCC_DIR";
@@ -210,12 +209,12 @@ static McuToolChainPackage *createArmGccToolchainPackage()
detectionPath,
"GNUArmEmbeddedToolchain", // settingsKey
McuToolChainPackage::ToolChainType::ArmGcc, // toolchainType
"QUL_TARGET_TOOLCHAIN_DIR", // cmake var
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
}
static McuToolChainPackage *createGhsToolchainPackage()
McuToolChainPackage *createGhsToolchainPackage()
{
const char envVar[] = "GHS_COMPILER_DIR";
@@ -231,12 +230,12 @@ static McuToolChainPackage *createGhsToolchainPackage()
FilePath("ccv850").withExecutableSuffix(), // detectionPath
"GHSToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHS, // toolchainType
"QUL_TARGET_TOOLCHAIN_DIR", // cmake var
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
}
static McuToolChainPackage *createGhsArmToolchainPackage()
McuToolChainPackage *createGhsArmToolchainPackage()
{
const char envVar[] = "GHS_ARM_COMPILER_DIR";
@@ -252,12 +251,12 @@ static McuToolChainPackage *createGhsArmToolchainPackage()
FilePath("cxarm").withExecutableSuffix(), // detectionPath
"GHSArmToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHSArm, // toolchainType
"QUL_TARGET_TOOLCHAIN_DIR", // cmake var
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
}
static McuToolChainPackage *createIarToolChainPackage()
McuToolChainPackage *createIarToolChainPackage()
{
const char envVar[] = "IAR_ARM_COMPILER_DIR";
@@ -286,7 +285,7 @@ static McuToolChainPackage *createIarToolChainPackage()
detectionPath,
"IARToolchain", // settings key
McuToolChainPackage::ToolChainType::IAR, // toolchainType
"QUL_TARGET_TOOLCHAIN_DIR", // cmake var
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
}
@@ -481,7 +480,7 @@ static QList<PackageDescription> parsePackages(const QJsonArray &cmakeEntries)
QList<PackageDescription> result;
for (const auto &cmakeEntryRef : cmakeEntries) {
const QJsonObject cmakeEntry{cmakeEntryRef.toObject()};
result.push_back({cmakeEntry[ID].toString(),
result.push_back({cmakeEntry["id"].toString(),
cmakeEntry["envVar"].toString(),
cmakeEntry["cmakeVar"].toString(),
cmakeEntry["description"].toString(),
@@ -505,10 +504,12 @@ McuTargetDescription parseDescriptionJson(const QByteArray &data)
const QJsonObject boardSdk = target.value("boardSdk").toObject();
const QJsonObject freeRTOS = target.value("freeRTOS").toObject();
QJsonArray cmakeEntries = freeRTOS.value(CMAKE_ENTRIES).toArray();
cmakeEntries.append(toolchain.value(CMAKE_ENTRIES).toArray());
cmakeEntries.append(boardSdk.value(CMAKE_ENTRIES).toArray());
const QList<PackageDescription> freeRtosEntries = parsePackages(cmakeEntries);
const QList<PackageDescription> toolchainEntries = parsePackages(
toolchain.value(CMAKE_ENTRIES).toArray());
const QList<PackageDescription> boardSDKEntries = parsePackages(
boardSdk.value(CMAKE_ENTRIES).toArray());
const QList<PackageDescription> freeRtosEntries = parsePackages(
freeRTOS.value(CMAKE_ENTRIES).toArray());
const QVariantList toolchainVersions = toolchain.value("versions").toArray().toVariantList();
const auto toolchainVersionsList = Utils::transform<QStringList>(toolchainVersions,
@@ -538,13 +539,13 @@ McuTargetDescription parseDescriptionJson(const QByteArray &data)
platformName == "Desktop" ? McuTargetDescription::TargetType::Desktop
: McuTargetDescription::TargetType::MCU,
},
{toolchain.value("id").toString(), toolchainVersionsList, {}},
{toolchain.value("id").toString(), toolchainVersionsList, toolchainEntries},
{
boardSdk.value("name").toString(),
boardSdk.value("defaultPath").toString(),
boardSdk.value("envVar").toString(),
boardSdkVersionsList,
{},
boardSDKEntries,
},
{
freeRTOS.value("envVar").toString(),

7
src/plugins/mcusupport/mcusupportsdk.h
View File

@@ -60,6 +60,13 @@ Utils::FilePath packagePathFromSettings(const QString &settingsKey,
const Utils::FilePath &defaultPath);
McuToolChainPackage *createUnsupportedToolChainPackage();
McuToolChainPackage *createIarToolChainPackage();
McuToolChainPackage *createGccToolChainPackage();
McuToolChainPackage *createArmGccToolchainPackage();
McuToolChainPackage *createMsvcToolChainPackage();
McuToolChainPackage *createGhsToolchainPackage();
McuToolChainPackage *createGhsArmToolchainPackage();
McuAbstractPackage *createBoardSdkPackage(const McuTargetDescription &desc);
McuAbstractPackage *createFreeRTOSSourcesPackage(const QString &envVar,
const Utils::FilePath &boardSdkDir,

8
src/plugins/mcusupport/mcutargetdescription.h
View File

@@ -52,7 +52,7 @@ struct McuTargetDescription
QString qulVersion;
QString compatVersion;
struct
struct Platform
{
QString id;
QString name;
@@ -60,13 +60,13 @@ struct McuTargetDescription
QVector<int> colorDepths;
TargetType type;
} platform;
struct
struct Toolchain
{
QString id;
QStringList versions;
QList<PackageDescription> packages;
} toolchain;
struct
struct BoardSdk
{
QString name;
QString defaultPath;
@@ -74,7 +74,7 @@ struct McuTargetDescription
QStringList versions;
QList<PackageDescription> packages;
} boardSdk;
struct
struct FreeRTOS
{
QString envVar;
QString boardSdkSubDir;

94
src/plugins/mcusupport/mcutargetfactory.cpp
View File

@@ -26,13 +26,41 @@
#include "mcutargetfactory.h"
#include "mcuhelpers.h"
#include "mcupackage.h"
#include "mcusupportconstants.h"
#include "mcutarget.h"
#include "mcutargetdescription.h"
#include <utils/algorithm.h>
#include <utils/qtcassert.h>
#include <QVersionNumber>
namespace McuSupport::Internal::Sdk {
bool isToolchainDescriptionValid(const McuTargetDescription::Toolchain &t)
{
bool result{true};
if (t.packages.isEmpty() || t.id.isEmpty())
result = false;
return result;
}
bool isDesktopToolchain(McuToolChainPackage::ToolChainType type)
{
return type == McuToolChainPackage::ToolChainType::MSVC
|| type == McuToolChainPackage::ToolChainType::GCC;
}
const static QMap<QString, McuToolChainPackage::ToolChainType> toolchainTypeMapping{
{"iar", McuToolChainPackage::ToolChainType::IAR},
{"keil", McuToolChainPackage::ToolChainType::KEIL},
{"msvc", McuToolChainPackage::ToolChainType::MSVC},
{"gcc", McuToolChainPackage::ToolChainType::GCC},
{"armgcc", McuToolChainPackage::ToolChainType::ArmGcc},
{"ghs", McuToolChainPackage::ToolChainType::GHS},
{"ghsarm", McuToolChainPackage::ToolChainType::GHSArm},
};
QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescription &desc)
{
Targets mcuTargets;
@@ -42,16 +70,17 @@ QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescript
const McuTarget::Platform platform(
{desc.platform.id, desc.platform.name, desc.platform.vendor});
auto *toolchain = createToolchain(desc.toolchain);
if (toolchain == nullptr)
continue;
Packages targetPackages = createPackages(desc);
packages.unite(targetPackages);
mcuTargets.append(McuTargetPtr{
new McuTarget{QVersionNumber::fromString(desc.qulVersion),
platform,
deduceOperatingSystem(desc),
targetPackages,
McuToolChainPackagePtr{new McuToolChainPackage{
{}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported}},
colorDepth}});
mcuTargets.append(McuTargetPtr{new McuTarget{QVersionNumber::fromString(desc.qulVersion),
platform,
deduceOperatingSystem(desc),
targetPackages,
McuToolChainPackagePtr{toolchain},
colorDepth}});
}
return {mcuTargets, packages};
}
@@ -71,17 +100,50 @@ Packages McuTargetFactory::createPackages(const McuTargetDescription &desc)
QList<PackageDescription> packageDescriptions = aggregatePackageEntries(desc);
for (const PackageDescription &pkgDesc : packageDescriptions) {
packages.insert(McuPackagePtr{new McuPackage{
pkgDesc.label,
pkgDesc.defaultPath,
pkgDesc.validationPath,
pkgDesc.setting,
pkgDesc.cmakeVar,
pkgDesc.envVar,
}});
packages.insert(createPackage(pkgDesc));
}
return packages;
}
McuPackagePtr McuTargetFactory::createPackage(const PackageDescription &pkgDesc)
{
return McuPackagePtr{new McuPackage{
pkgDesc.label,
pkgDesc.defaultPath,
pkgDesc.validationPath,
pkgDesc.setting,
pkgDesc.cmakeVar,
pkgDesc.envVar,
}};
}
McuToolChainPackage *McuTargetFactory::createToolchain(
const McuTargetDescription::Toolchain &toolchain)
{
const PackageDescription compilerDescription
= Utils::findOrDefault(toolchain.packages, [](const PackageDescription &desc) {
return desc.cmakeVar == Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE;
});
McuToolChainPackage::ToolChainType toolchainType
= toolchainTypeMapping.value(toolchain.id, McuToolChainPackage::ToolChainType::Unsupported);
if (isDesktopToolchain(toolchainType))
return new McuToolChainPackage{{}, {}, {}, {}, toolchainType};
else if (!isToolchainDescriptionValid(toolchain))
return nullptr;
return new McuToolChainPackage{
compilerDescription.label,
compilerDescription.defaultPath,
compilerDescription.validationPath,
compilerDescription.setting,
toolchainType,
compilerDescription.cmakeVar,
compilerDescription.envVar,
nullptr,
};
}
} // namespace McuSupport::Internal::Sdk

5
src/plugins/mcusupport/mcutargetfactory.h
View File

@@ -26,14 +26,19 @@
#pragma once
#include "mcuabstracttargetfactory.h"
#include "mcutargetdescription.h"
namespace McuSupport::Internal::Sdk {
struct PackageDescription;
class McuTargetFactory : public McuAbstractTargetFactory
{
public:
QPair<Targets, Packages> createTargets(const McuTargetDescription &) override;
Packages createPackages(const McuTargetDescription &);
McuToolChainPackage *createToolchain(const McuTargetDescription::Toolchain &);
McuPackagePtr createPackage(const PackageDescription &);
}; // struct McuTargetFactory
} // namespace McuSupport::Internal::Sdk

12
src/plugins/mcusupport/mcutargetfactorylegacy.cpp
View File

@@ -89,12 +89,12 @@ QPair<Targets, Packages> McuTargetFactoryLegacy::createTargets(const McuTargetDe
packages.unite(required3rdPartyPkgs);
const McuTarget::Platform platform(
{desc.platform.id, desc.platform.name, desc.platform.vendor});
mcuTargets.push_back(McuTargetPtr{new McuTarget{QVersionNumber::fromString(desc.qulVersion),
platform,
deduceOperatingSystem(desc),
required3rdPartyPkgs,
tcPkg,
colorDepth}});
mcuTargets.append(McuTargetPtr{new McuTarget{QVersionNumber::fromString(desc.qulVersion),
platform,
deduceOperatingSystem(desc),
required3rdPartyPkgs,
tcPkg,
colorDepth}});
}
return {mcuTargets, packages};
}

12
src/plugins/mcusupport/test/armgcc_nxp_1050_json.h
View File

@@ -41,14 +41,14 @@ constexpr auto armgcc_nxp_1050_json = R"({
"id": "Qul_DIR",
"description": "Qt for MCUs SDK",
"type": "path",
"cmakeOptionName": "Qul_ROOT",
"cmakeVar": "Qul_ROOT",
"optional": false
},
{
"id": "MCU_XPRESSO_PATH",
"description": "MCUXpresso IDE",
"type": "path",
"cmakeOptionName": "MCUXPRESSO_IDE_PATH",
"cmakeVar": "MCUXPRESSO_IDE_PATH",
"defaultValue": {
"windows": "$ROOT/nxp/MCUXpressoIDE*",
"unix": "/usr/local/mcuxpressoide/"
@@ -66,14 +66,14 @@ constexpr auto armgcc_nxp_1050_json = R"({
{
"id": "ARMGCC_DIR",
"description": "GNU Arm Embedded Toolchain",
"cmakeOptionName": "QUL_TARGET_TOOLCHAIN_DIR",
"cmakeVar": "QUL_TARGET_TOOLCHAIN_DIR",
"type": "path",
"optional": false
},
{
"id": "ARMGCC_CMAKE_TOOLCHAIN_FILE",
"description": "CMake Toolchain File",
"cmakeOptionName": "CMAKE_TOOLCHAIN_FILE",
"cmakeVar": "CMAKE_TOOLCHAIN_FILE",
"type": "file",
"defaultValue": "$Qul_ROOT/lib/cmake/Qul/toolchain/armgcc.cmake",
"visible": false,
@@ -90,7 +90,7 @@ constexpr auto armgcc_nxp_1050_json = R"({
{
"id": "NXP_SDK_DIR",
"description": "Board SDK for MIMXRT1050-EVK",
"cmakeOptionName": "QUL_BOARD_SDK_DIR",
"cmakeVar": "QUL_BOARD_SDK_DIR",
"type": "path",
"optional": false
}
@@ -102,7 +102,7 @@ constexpr auto armgcc_nxp_1050_json = R"({
{
"id": "NXP_FREERTOS_DIR",
"description": "FreeRTOS SDK for MIMXRT1050-EVK",
"cmakeOptionName": "FREERTOS_DIR",
"cmakeVar": "FREERTOS_DIR",
"defaultValue": "$QUL_BOARD_SDK_DIR/rtos/freertos/freertos_kernel",
"type": "path",
"optional": false

2
src/plugins/mcusupport/test/armgcc_stm32h750b_metal_json.h
View File

@@ -62,7 +62,7 @@ constexpr auto armgcc_stm32h750b_metal_json = R"({
"versions": [
"9.3.1"
],
"cmakeCacheEntries": [
"cmakeEntries": [
{
"id": "ARMGCC_DIR",
"description": "GNU Arm Embedded Toolchain",

55
src/plugins/mcusupport/test/gcc_desktop_json.h Normal file
View File

@@ -0,0 +1,55 @@
/****************************************************************************
**
** 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 gcc_desktop_json = R"({
"qulVersion": "@CMAKE_PROJECT_VERSION@",
"compatVersion": "@COMPATIBILITY_VERSION@",
"platform": {
"id": "Qt",
"platformName": "Desktop",
"vendor": "Qt",
"colorDepths": [
32
],
"pathEntries": [
],
"environmentEntries": [
],
"cmakeEntries": [
{
"id": "Qul_DIR",
"label": "Qt for MCUs SDK",
"type": "path",
"cmakeVar": "Qul_ROOT",
"optional": false
}
]
},
"toolchain": {
"id": "gcc"
}
})";

12
src/plugins/mcusupport/test/armgcc_nxp_1064_json.h → src/plugins/mcusupport/test/iar_nxp_1064_json.h
View File

@@ -25,13 +25,13 @@
#pragma once
constexpr auto armgcc_nxp_1064_json = R"({
constexpr auto iar_nxp_1064_json = R"({
"compatVersion": "1",
"qulVersion": "2.0.0",
"boardSdk": {
"cmakeEntries": [
{
"cmakeOptionName": "QUL_BOARD_SDK_DIR",
"cmakeVar": "QUL_BOARD_SDK_DIR",
"description": "Board SDK for MIMXRT1064-EVK",
"id": "NXP_SDK_DIR",
"optional": false,
@@ -61,14 +61,14 @@ constexpr auto armgcc_nxp_1064_json = R"({
"platform": {
"cmakeEntries": [
{
"cmakeOptionName": "Qul_ROOT",
"cmakeVar": "Qul_ROOT",
"description": "Qt for MCUs SDK",
"id": "Qul_DIR",
"optional": false,
"type": "path"
},
{
"cmakeOptionName": "MCUXPRESSO_IDE_PATH",
"cmakeVar": "MCUXPRESSO_IDE_PATH",
"defaultValue": {
"unix": "/usr/local/mcuxpressoide/",
"windows": "$ROOT/nxp/MCUXpressoIDE*"
@@ -85,9 +85,9 @@ constexpr auto armgcc_nxp_1064_json = R"({
"toolchain": {
"cmakeEntries": [
{
"cmakeOptionName": "QUL_TARGET_TOOLCHAIN_DIR",
"description": "IAR ARM Compiler",
"id": "IAR_DIR",
"cmakeVar": "QUL_TARGET_TOOLCHAIN_DIR",
"description": "IAR ARM Compiler",
"optional": false,
"type": "path"
}

9
src/plugins/mcusupport/test/iar_stm32f469i_metal_json.h
View File

@@ -52,7 +52,7 @@ constexpr auto iar_stm32f469i_metal_json = R"({
"id": "Qul_DIR",
"description": "Qt for MCUs SDK",
"type": "path",
"cmakeOptionName": "Qul_ROOT",
"cmakeVar": "Qul_ROOT",
"optional": false
}
]
@@ -65,16 +65,17 @@ constexpr auto iar_stm32f469i_metal_json = R"({
"cmakeEntries": [
{
"id": "IARToolchain",
"setting": "IARToolchain",
"envVar": "IAR_ARM_COMPILER_DIR",
"description": "IAR ARM Compiler",
"cmakeOptionName": "QUL_TARGET_TOOLCHAIN_DIR",
"cmakeVar": "QUL_TARGET_TOOLCHAIN_DIR",
"type": "path",
"optional": false
},
{
"id": "IAR_CMAKE_TOOLCHAIN_FILE",
"description": "CMake Toolchain File",
"cmakeOptionName": "CMAKE_TOOLCHAIN_FILE",
"cmakeVar": "CMAKE_TOOLCHAIN_FILE",
"type": "file",
"defaultValue": "$Qul_ROOT/lib/cmake/Qul/toolchain/iar.cmake",
"visible": false,
@@ -91,7 +92,7 @@ constexpr auto iar_stm32f469i_metal_json = R"({
{
"id": "ST_SDK_DIR",
"description": "Board SDK for STM32F469I-Discovery",
"cmakeOptionName": "QUL_BOARD_SDK_DIR",
"cmakeVar": "QUL_BOARD_SDK_DIR",
"type": "path",
"optional": false
}

4
src/plugins/mcusupport/test/packagemock.h
View File

@@ -46,8 +46,8 @@ public:
MOCK_METHOD(Status, status, (), (const));
MOCK_METHOD(bool, isValidStatus, (), (const));
MOCK_METHOD(const QString &, cmakeVariableName, (), (const));
MOCK_METHOD(const QString &, environmentVariableName, (), (const));
MOCK_METHOD(QString, cmakeVariableName, (), (const));
MOCK_METHOD(QString, environmentVariableName, (), (const));
MOCK_METHOD(bool, isAddToSystemPath, (), (const));
MOCK_METHOD(bool, writeToSettings, (), (const));
MOCK_METHOD(void, setVersions, (const QStringList &) );

357
src/plugins/mcusupport/test/unittest.cpp
View File

@@ -25,10 +25,12 @@
#include "unittest.h"
#include "armgcc_nxp_1050_json.h"
#include "armgcc_nxp_1064_json.h"
#include "armgcc_stm32f769i_freertos_json.h"
#include "armgcc_stm32h750b_metal_json.h"
#include "gcc_desktop_json.h"
#include "iar_nxp_1064_json.h"
#include "iar_stm32f469i_metal_json.h"
#include "mcuhelpers.h"
#include "mcukitmanager.h"
#include "mcusupportconstants.h"
@@ -36,49 +38,143 @@
#include "mcutargetdescription.h"
#include "mcutargetfactory.h"
#include "mcutargetfactorylegacy.h"
#include <baremetal/baremetalconstants.h>
#include <cmakeprojectmanager/cmakeconfigitem.h>
#include <cmakeprojectmanager/cmakekitinformation.h>
#include <gmock/gmock-actions.h>
#include <gmock/gmock.h>
#include <projectexplorer/customtoolchain.h>
#include <projectexplorer/toolchain.h>
#include <projectexplorer/toolchainmanager.h>
#include <utils/algorithm.h>
#include <utils/filepath.h>
#include <cmakeprojectmanager/cmakeconfigitem.h>
#include <cmakeprojectmanager/cmakekitinformation.h>
#include <gmock/gmock.h>
#include <QJsonArray>
#include <QJsonDocument>
#include <qtestcase.h>
#include <algorithm>
#include <ciso646>
namespace McuSupport::Internal::Test {
namespace {
// clazy:excludeall=non-pod-global-static
const QString freeRtosCMakeVar{"FREERTOS_DIR"};
const QString nxp1050FreeRtosEnvVar{"IMXRT1050_FREERTOS_DIR"};
const QString nxp1064FreeRtosEnvVar{"IMXRT1064_FREERTOS_DIR"};
const QString nxp1170FreeRtosEnvVar{"EVK_MIMXRT1170_FREERTOS_PATH"};
const QString stm32f7FreeRtosEnvVar{"STM32F7_FREERTOS_DIR"};
const QString stm32f7{"STM32F7"};
const QString nxp1170{"EVK_MIMXRT1170"};
const QString nxp1050{"IMXRT1050"};
const QString nxp1064{"IMXRT1064"};
const char id[]{"target_id"};
const char name[]{"target_name"};
const char vendor[]{"target_vendor"};
const char armgcc[]{"armgcc"};
const char cmakeExtension[]{".cmake"};
const char defaultfreeRtosPath[]{"/opt/freertos/default"};
const char freeRtosCMakeVar[]{"FREERTOS_DIR"};
const char freeRtosEnvVar[]{"EVK_MIMXRT1170_FREERTOS_PATH"};
const char gcc[]{"armgcc"};
const char iarEnvVar[]{"IAR_ARM_COMPILER_DIR"};
const char iarLabel[]{"IAR ARM Compiler"};
const char iarSetting[]{"IARToolchain"};
const char iar[]{"iar"};
const char nxp1050FreeRtosEnvVar[]{"IMXRT1050_FREERTOS_DIR"};
const char nxp1050[]{"IMXRT1050"};
const char nxp1064FreeRtosEnvVar[]{"IMXRT1064_FREERTOS_DIR"};
const char nxp1064[]{"IMXRT1064"};
const char nxp1170FreeRtosEnvVar[]{"EVK_MIMXRT1170_FREERTOS_PATH"};
const char nxp1170[]{"EVK_MIMXRT1170"};
const char stm32f7FreeRtosEnvVar[]{"STM32F7_FREERTOS_DIR"};
const char stm32f7[]{"STM32F7"};
const char unsupported[]{"unsupported"};
const QStringList jsonFiles{QString::fromUtf8(armgcc_nxp_1050_json),
QString::fromUtf8(armgcc_nxp_1064_json)};
constexpr bool RUN_LEGACY{true};
constexpr int colorDepth{32};
const QString id{"id"};
QString::fromUtf8(iar_nxp_1064_json)};
const bool runLegacy{true};
const int colorDepth{32};
const Sdk::McuTargetDescription::Platform platform{id,
"",
"",
{colorDepth},
Sdk::McuTargetDescription::TargetType::MCU};
const Utils::Id cxxLanguageId{ProjectExplorer::Constants::CXX_LANGUAGE_ID};
} // namespace
using CMakeProjectManager::CMakeConfigItem;
using CMakeProjectManager::CMakeConfigurationKitAspect;
using ProjectExplorer::EnvironmentKitAspect;
using ProjectExplorer::Kit;
using ProjectExplorer::KitManager;
using ProjectExplorer::ToolChain;
using ProjectExplorer::ToolChainManager;
using testing::Return;
using Utils::FilePath;
void McuSupportTest::initTestCase() {}
void verifyIarToolchain(const McuToolChainPackage *iarToolchainPackage)
{
QVERIFY(iarToolchainPackage != nullptr);
QCOMPARE(iarToolchainPackage->cmakeToolChainFileName(), QString{iar}.append(cmakeExtension));
QCOMPARE(iarToolchainPackage->cmakeVariableName(), Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE);
QCOMPARE(iarToolchainPackage->environmentVariableName(), iarEnvVar);
QCOMPARE(iarToolchainPackage->isDesktopToolchain(), false);
QCOMPARE(iarToolchainPackage->toolChainName(), iar);
QCOMPARE(iarToolchainPackage->toolchainType(), McuToolChainPackage::ToolChainType::IAR);
ProjectExplorer::ToolChainFactory toolchainFactory;
Utils::Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
ToolChain *iar{toolchainFactory.createToolChain(iarId)};
iar->setLanguage(cxxLanguageId);
ToolChainManager::instance()->registerToolChain(iar);
ToolChain *iarToolchain{iarToolchainPackage->toolChain(cxxLanguageId)};
QVERIFY(iarToolchain != nullptr);
QCOMPARE(iarToolchain->displayName(), "IAREW");
QCOMPARE(iarToolchain->detection(), ToolChain::UninitializedDetection);
}
void verifyGccToolchain(const McuToolChainPackage *gccPackage)
{
QVERIFY(gccPackage != nullptr);
QCOMPARE(gccPackage->cmakeToolChainFileName(), QString{unsupported}.append(cmakeExtension));
QCOMPARE(gccPackage->cmakeVariableName(), "");
QCOMPARE(gccPackage->environmentVariableName(), "");
QCOMPARE(gccPackage->isDesktopToolchain(), true);
QCOMPARE(gccPackage->toolChainName(), unsupported);
QCOMPARE(gccPackage->toolchainType(), McuToolChainPackage::ToolChainType::GCC);
}
void McuSupportTest::initTestCase()
{
targetDescription = Sdk::McuTargetDescription{
"2.0.1",
"2",
platform,
Sdk::McuTargetDescription::Toolchain{},
Sdk::McuTargetDescription::BoardSdk{},
Sdk::McuTargetDescription::FreeRTOS{},
};
EXPECT_CALL(*freeRtosPackage, environmentVariableName())
.WillRepeatedly(Return(QString{freeRtosEnvVar}));
EXPECT_CALL(*freeRtosPackage, cmakeVariableName())
.WillRepeatedly(Return(QString{freeRtosCMakeVar}));
EXPECT_CALL(*freeRtosPackage, isValidStatus()).WillRepeatedly(Return(true));
EXPECT_CALL(*freeRtosPackage, path())
.WillRepeatedly(Return(FilePath::fromString(defaultfreeRtosPath)));
EXPECT_CALL(*freeRtosPackage, isAddToSystemPath()).WillRepeatedly(Return(true));
EXPECT_CALL(*freeRtosPackage, detectionPath()).WillRepeatedly(Return(Utils::FilePath{}));
EXPECT_CALL(*sdkPackage, environmentVariableName())
.WillRepeatedly(Return(QString{freeRtosEnvVar}));
EXPECT_CALL(*sdkPackage, cmakeVariableName()).WillRepeatedly(Return(QString{freeRtosCMakeVar}));
EXPECT_CALL(*sdkPackage, isValidStatus()).WillRepeatedly(Return(true));
EXPECT_CALL(*sdkPackage, path())
.WillRepeatedly(Return(FilePath::fromString(defaultfreeRtosPath)));
EXPECT_CALL(*sdkPackage, isAddToSystemPath()).WillRepeatedly(Return(true));
EXPECT_CALL(*sdkPackage, detectionPath()).WillRepeatedly(Return(Utils::FilePath{}));
}
void McuSupportTest::test_parseBasicInfoFromJson()
{
const auto description = Sdk::parseDescriptionJson(armgcc_nxp_1064_json);
const auto description = Sdk::parseDescriptionJson(iar_nxp_1064_json);
QVERIFY(!description.freeRTOS.envVar.isEmpty());
QVERIFY(description.freeRTOS.boardSdkSubDir.isEmpty());
@@ -86,49 +182,54 @@ void McuSupportTest::test_parseBasicInfoFromJson()
void McuSupportTest::test_parseCmakeEntries()
{
const auto description{Sdk::parseDescriptionJson(armgcc_nxp_1064_json)};
const auto description{Sdk::parseDescriptionJson(iar_nxp_1064_json)};
QVERIFY(not description.freeRTOS.packages.isEmpty());
QVERIFY(!description.freeRTOS.packages.isEmpty());
auto &freeRtosPackage = description.freeRTOS.packages[0];
QCOMPARE(freeRtosPackage.envVar, nxp1064FreeRtosEnvVar);
}
void McuSupportTest::test_parseToolchainFromJSON()
{
Sdk::McuTargetDescription description{Sdk::parseDescriptionJson(iar_stm32f469i_metal_json)};
QCOMPARE(description.toolchain.id, iar);
QCOMPARE(description.toolchain.packages.size(), 2);
const Sdk::PackageDescription &compilerPackage{description.toolchain.packages.at(0)};
QCOMPARE(compilerPackage.cmakeVar, Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE);
QCOMPARE(compilerPackage.envVar, "IAR_ARM_COMPILER_DIR");
const Sdk::PackageDescription &toolchainFilePackage{description.toolchain.packages.at(1)};
QCOMPARE(toolchainFilePackage.label, "IAR_CMAKE_TOOLCHAIN_FILE");
QCOMPARE(toolchainFilePackage.envVar, QString{});
QCOMPARE(toolchainFilePackage.cmakeVar, Constants::TOOLCHAIN_FILE_CMAKE_VARIABLE);
QCOMPARE(toolchainFilePackage.description, "CMake Toolchain File");
QCOMPARE(toolchainFilePackage.defaultPath, "$Qul_ROOT/lib/cmake/Qul/toolchain/iar.cmake");
}
void McuSupportTest::test_addNewKit()
{
const QString cmakeVar = "CMAKE_SDK";
McuPackagePtr sdkPackage{new McuPackage{"sdk", // label
{}, // defaultPath
{}, // detectionPath
"sdk", // settingsKey
cmakeVar, // cmake var
{}}}; // env var
ProjectExplorer::Kit kit;
EXPECT_CALL(*sdkPackage, cmakeVariableName()).WillRepeatedly(Return(cmakeVar));
Kit kit;
McuToolChainPackagePtr toolchainPackage{
new McuToolChainPackage{{}, // label
{}, // defaultPath
{}, // detectionPath
{}, // settingsKey
McuToolChainPackage::ToolChainType::Unsupported, // toolchain type
{}, // cmake var name
{}}}; // env var name
const McuTarget::Platform platform{id, name, vendor};
McuTarget mcuTarget{currentQulVersion, // version
platform, // platform
McuTarget::OS::FreeRTOS, // os
{sdkPackage}, // packages
toolchainPackage}; // toolchain packages
McuTarget mcuTarget{currentQulVersion, // version
platform, // platform
McuTarget::OS::FreeRTOS, // os
{sdkPackagePtr, freeRtosPackagePtr}, // packages
toolchainPackagePtr}; // toolchain packages
auto &kitManager{*KitManager::instance()};
QSignalSpy kitAddedSpy(&kitManager, &KitManager::kitAdded);
auto *newKit{McuKitManager::newKit(&mcuTarget, sdkPackage)};
auto *newKit{McuKitManager::newKit(&mcuTarget, sdkPackagePtr)};
QVERIFY(newKit != nullptr);
QCOMPARE(kitAddedSpy.count(), 1);
QList<QVariant> arguments = kitAddedSpy.takeFirst();
auto *createdKit = qvariant_cast<ProjectExplorer::Kit *>(arguments.at(0));
auto *createdKit = qvariant_cast<Kit *>(arguments.at(0));
QVERIFY(createdKit != nullptr);
QCOMPARE(createdKit, newKit);
@@ -141,6 +242,110 @@ void McuSupportTest::test_addNewKit()
!= -1);
}
void McuSupportTest::test_addFreeRtosCmakeVarToKit()
{
Kit kit;
const McuTarget::Platform platform{id, name, vendor};
McuTarget mcuTarget{currentQulVersion,
platform,
McuTarget::OS::FreeRTOS,
{sdkPackagePtr, freeRtosPackagePtr},
toolchainPackagePtr};
McuKitManager::upgradeKitInPlace(&kit, &mcuTarget, sdkPackagePtr);
QVERIFY(kit.hasValue(EnvironmentKitAspect::id()));
QVERIFY(kit.isValid());
QVERIFY(!kit.allKeys().empty());
const auto &cmakeConfig{CMakeConfigurationKitAspect::configuration(&kit)};
QCOMPARE(cmakeConfig.size(), 8);
CMakeConfigItem
expectedCmakeVar{freeRtosCMakeVar,
FilePath::fromString(defaultfreeRtosPath).toUserOutput().toLocal8Bit()};
QVERIFY(cmakeConfig.contains(expectedCmakeVar));
const auto config = CMakeConfigurationKitAspect::configuration(&kit);
QVERIFY(config.size() > 0);
}
void McuSupportTest::test_legacy_createIarToolchain()
{
McuToolChainPackage *iarToolchainPackage = Sdk::createIarToolChainPackage();
verifyIarToolchain(iarToolchainPackage);
}
void McuSupportTest::test_createIarToolchain()
{
const auto description = Sdk::parseDescriptionJson(iar_stm32f469i_metal_json);
McuToolChainPackage *iarToolchainPackage{targetFactory.createToolchain(description.toolchain)};
verifyIarToolchain(iarToolchainPackage);
}
void McuSupportTest::test_legacy_createDesktopGccToolchain()
{
McuToolChainPackage *gccPackage = Sdk::createGccToolChainPackage();
verifyGccToolchain(gccPackage);
}
void McuSupportTest::test_createDesktopGccToolchain()
{
const auto description = Sdk::parseDescriptionJson(gcc_desktop_json);
McuToolChainPackage *gccPackage{targetFactory.createToolchain(description.toolchain)};
verifyGccToolchain(gccPackage);
}
void McuSupportTest::test_skipTargetCreationWhenToolchainInfoIsMissing()
{
const auto [targets, packages]{targetFactory.createTargets(targetDescription)};
QVERIFY(targets.isEmpty());
}
void McuSupportTest::test_returnNullWhenCreatingToolchainIfInfoIsMissing()
{
Sdk::McuTargetDescription::Toolchain toolchainDescription{};
toolchainDescription.id = iar;
McuToolChainPackage *toolchain{targetFactory.createToolchain(toolchainDescription)};
QCOMPARE(toolchain, nullptr);
}
void McuSupportTest::test_returnNullWhenCreatingToolchainIfIdIsEmpty()
{
McuToolChainPackage *toolchain{targetFactory.createToolchain({})};
QCOMPARE(toolchain, nullptr);
}
void McuSupportTest::test_defaultToolchainPackageCtorShouldReturnDefaultToolchainFileName()
{
QVERIFY(!toolchainPackagePtr->cmakeToolChainFileName().isEmpty());
QCOMPARE(toolchainPackagePtr->cmakeToolChainFileName(),
QString{unsupported}.append(cmakeExtension));
}
void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType_data()
{
QTest::addColumn<Sdk::McuTargetDescription>("description");
QTest::addColumn<McuToolChainPackage::ToolChainType>("toolchainType");
QTest::newRow("armgcc_stm32h750b") << Sdk::parseDescriptionJson(armgcc_stm32h750b_metal_json)
<< McuToolChainPackage::ToolChainType::ArmGcc;
QTest::newRow("iar_nxp1064") << Sdk::parseDescriptionJson(iar_nxp_1064_json)
<< McuToolChainPackage::ToolChainType::IAR;
QTest::newRow("iar_stm32f469i") << Sdk::parseDescriptionJson(iar_stm32f469i_metal_json)
<< McuToolChainPackage::ToolChainType::IAR;
}
void McuSupportTest::test_mapParsedToolchainIdToCorrespondingType()
{
QFETCH(Sdk::McuTargetDescription, description);
QFETCH(McuToolChainPackage::ToolChainType, toolchainType);
const McuToolChainPackage *toolchain{targetFactory.createToolchain(description.toolchain)};
QVERIFY(toolchain != nullptr);
QCOMPARE(toolchain->toolchainType(), toolchainType);
}
void McuSupportTest::test_createPackagesWithCorrespondingSettings_data()
{
QTest::addColumn<QString>("json");
@@ -155,7 +360,7 @@ void McuSupportTest::test_createPackagesWithCorrespondingSettings_data()
{"RenesasFlashProgrammer"},
{"Stm32CubeProgrammer"}};
QTest::newRow("nxp1064") << armgcc_nxp_1064_json
QTest::newRow("nxp1064") << iar_nxp_1064_json
<< QSet<QString>{{"EVK_MIMXRT1064_SDK_PATH"},
{QString{Constants::SETTINGS_KEY_FREERTOS_PREFIX}
.append("IMXRT1064")}}
@@ -180,7 +385,7 @@ void McuSupportTest::test_createPackagesWithCorrespondingSettings()
{
QFETCH(QString, json);
const Sdk::McuTargetDescription description = Sdk::parseDescriptionJson(json.toLocal8Bit());
const auto [targets, packages]{Sdk::targetsFromDescriptions({description}, RUN_LEGACY)};
const auto [targets, packages]{Sdk::targetsFromDescriptions({description}, runLegacy)};
Q_UNUSED(targets);
QSet<QString> settings = Utils::transform<QSet<QString>>(packages, [](const auto &package) {
@@ -205,19 +410,8 @@ void McuSupportTest::test_createFreeRtosPackageWithCorrectSetting_data()
<< QString{Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(stm32f7);
}
//TODO(piotr.mucko): Enable when mcutargetfactory is delivered.
void McuSupportTest::test_createFreeRtosPackageWithCorrectSetting()
{
// Sdk::targetsAndPackages(jsonFile, &mcuSdkRepo);
//
// QVector<Package *> mcuPackages;
// auto mcuTargets = Sdk::targetsFromDescriptions({description}, &mcuPackages);
// QVERIFY(mcuPackages contains freertos package)
// QVERIFY(freertos package is not empty & has proper value)
// McuSupportOptions mcuSuportOptions{};
// mcuSuportOptions.createAutomaticKits();
QFETCH(QString, freeRtosEnvVar);
QFETCH(QString, expectedSettingsKey);
@@ -225,23 +419,9 @@ void McuSupportTest::test_createFreeRtosPackageWithCorrectSetting()
QVERIFY(package != nullptr);
QCOMPARE(package->settingsKey(), expectedSettingsKey);
// QVERIFY(freertos package is not empty & has proper value)
// static McuPackage *createFreeRTOSSourcesPackage(const QString &envVar,
// const FilePath &boardSdkDir,
// const QString &freeRTOSBoardSdkSubDir)
// createFreeRtosPackage
// verify that package's setting is Package_FreeRTOSSourcePackage_IMXRT1064.
//TODO(me): write settings
// auto *freeRtosPackage
// = new McuPackage;
// freeRtosPackage->writeToSettings();
//TODO(me): verify that setting is the same as in 2.0.0
}
void McuSupportTest::test_createTargetsTheNewWay_data() {}
void McuSupportTest::test_createTargetsTheNewWay()
void McuSupportTest::test_createTargets()
{
Sdk::PackageDescription packageDescription{id,
nxp1064FreeRtosEnvVar,
@@ -252,23 +432,16 @@ void McuSupportTest::test_createTargetsTheNewWay()
"",
{},
true};
targetDescription.freeRTOS.packages.append(packageDescription);
targetDescription.toolchain.id = armgcc;
targetDescription.toolchain.packages.append(Sdk::PackageDescription{});
Sdk::McuTargetDescription description{
"2.0.1",
"2",
{id, "", "", {colorDepth}, Sdk::McuTargetDescription::TargetType::MCU},
{}, // toolchain
{}, // boardSDK
{"", "", {packageDescription}}, //freertos
};
Sdk::McuTargetFactory targetFactory{};
const auto [targets, packages]{targetFactory.createTargets(description)};
QVERIFY(not targets.empty());
const auto [targets, packages]{targetFactory.createTargets(targetDescription)};
QVERIFY(!targets.empty());
const McuTargetPtr target{*targets.constBegin()};
QCOMPARE(target->colorDepth(), colorDepth);
const auto &tgtPackages{target->packages()};
QVERIFY(not tgtPackages.empty());
QVERIFY(!tgtPackages.empty());
const auto rtosPackage{*tgtPackages.constBegin()};
QCOMPARE(rtosPackage->environmentVariableName(), nxp1064FreeRtosEnvVar);
}
@@ -284,18 +457,10 @@ void McuSupportTest::test_createPackages()
"",
{},
true};
Sdk::McuTargetDescription targetDescription{
"2.0.1",
"2",
{id, id, id, {colorDepth}, Sdk::McuTargetDescription::TargetType::MCU},
{}, // toolchain
{}, // boardSDK
{"", "", {packageDescription}}, //freertos
};
targetDescription.freeRTOS.packages.append(packageDescription);
Sdk::McuTargetFactory targetFactory;
const auto packages{targetFactory.createPackages(targetDescription)};
QVERIFY(not packages.empty());
QVERIFY(!packages.empty());
}
void McuSupportTest::test_removeRtosSuffix_data()

39
src/plugins/mcusupport/test/unittest.h
View File

@@ -30,6 +30,7 @@
#include "mcusupportplugin.h"
#include "mcusupportsdk.h"
#include "mcutarget.h"
#include "mcutargetfactory.h"
#include "packagemock.h"
#include <projectexplorer/kit.h>
@@ -52,27 +53,45 @@ private slots:
void test_addNewKit();
void test_parseBasicInfoFromJson();
void test_parseCmakeEntries();
void test_parseToolchainFromJSON();
void test_mapParsedToolchainIdToCorrespondingType_data();
void test_mapParsedToolchainIdToCorrespondingType();
void test_defaultToolchainPackageCtorShouldReturnDefaultToolchainFileName();
void test_createPackagesWithCorrespondingSettings();
void test_createPackagesWithCorrespondingSettings_data();
void test_createFreeRtosPackageWithCorrectSetting_data();
void test_createFreeRtosPackageWithCorrectSetting();
void test_createTargetsTheNewWay_data();
void test_createTargetsTheNewWay();
void test_skipTargetCreationWhenToolchainInfoIsMissing();
void test_returnNullWhenCreatingToolchainIfInfoIsMissing();
void test_returnNullWhenCreatingToolchainIfIdIsEmpty();
void test_createTargets();
void test_createPackages();
void test_parseCmakeEntries();
void test_addFreeRtosCmakeVarToKit();
void test_legacy_createIarToolchain();
void test_createIarToolchain();
void test_legacy_createDesktopGccToolchain();
void test_createDesktopGccToolchain();
void test_removeRtosSuffix_data();
void test_removeRtosSuffix();
void test_2dot1UsesLegacyImplementation();
private:
QVersionNumber currentQulVersion{2, 0};
const QString id{"target_id"};
const QString name{"target_name"};
const QString vendor{"target_vendor"};
const QString freeRtosEnvVar{"EVK_MIMXRT1170_FREERTOS_PATH"};
const QString freeRtosCmakeVar{"FREERTOS_DIR"};
const QString defaultfreeRtosPath{"/opt/freertos/default"};
PackageMock *freeRtosPackage{new PackageMock};
PackageMock *sdkPackage{new PackageMock};
McuPackagePtr freeRtosPackagePtr{freeRtosPackage};
McuPackagePtr sdkPackagePtr{sdkPackage};
Sdk::McuTargetFactory targetFactory;
Sdk::McuTargetDescription targetDescription;
McuToolChainPackagePtr toolchainPackagePtr{
new McuToolChainPackage{{}, // label
{}, // defaultPath
{}, // detectionPath
{}, // settingsKey
McuToolChainPackage::ToolChainType::Unsupported, // toolchain type
{}, // cmake var name
{}}}; // env var name
}; // class McuSupportTest
} // namespace McuSupport::Internal::Test