bool AddToolChainOperation::test() const
{
QVariantMap map = initializeToolChains();
// Add toolchain:
map = addToolChain(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("/tmp/test"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
if (map.value(QLatin1String(COUNT)).toInt() != 1
|| !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('0')))
return false;
QVariantMap tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('0')).toMap();
if (tcData.count() != 7
|| tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId")
|| tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name")
|| tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
|| tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
|| tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
|| tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
|| tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
return false;
// Ignore same Id:
QVariantMap unchanged = addToolChain(map, QLatin1String("testId"), QLatin1String("name2"), QLatin1String("/tmp/test2"),
QLatin1String("test-abi2"), QLatin1String("test-abi2,test-abi3"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue2"))));
if (!unchanged.isEmpty())
return false;
// Make sure name stays unique:
map = addToolChain(map, QLatin1String("testId2"), QLatin1String("name"), QLatin1String("/tmp/test"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
if (map.value(QLatin1String(COUNT)).toInt() != 2
|| !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('0'))
|| !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('1')))
return false;
tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('0')).toMap();
if (tcData.count() != 7
|| tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId")
|| tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name")
|| tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
|| tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
|| tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
|| tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
|| tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
return false;
tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('1')).toMap();
if (tcData.count() != 7
|| tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId2")
|| tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name2")
|| tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
|| tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
|| tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
|| tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
|| tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
return false;
return true;
}
bool RmKitOperation::test() const
{
QVariantMap map =
AddKitOperation::addKit(AddKitOperation::initializeKits(),
QLatin1String("testId"), QLatin1String("Test Qt Version"),
QLatin1String("/tmp/icon.png"),
1, QLatin1String("/usr/bin/gdb-test"),
QByteArray("Desktop"), QString(),
QLatin1String("{some-tc-id}"), QLatin1String("{some-qt-id}"),
QLatin1String("unsupported/mkspec"),
KeyValuePairList() << KeyValuePair(QLatin1String("PE.Profile.Data/extraData"), QVariant(QLatin1String("extraValue"))));
map =
AddKitOperation::addKit(map, QLatin1String("testId2"), QLatin1String("Test Qt Version"),
QLatin1String("/tmp/icon2.png"),
1, QLatin1String("/usr/bin/gdb-test2"),
QByteArray("Desktop"), QString(),
QLatin1String("{some-tc-id2}"), QLatin1String("{some-qt-id2}"),
QLatin1String("unsupported/mkspec2"),
KeyValuePairList() << KeyValuePair(QLatin1String("PE.Profile.Data/extraData"), QVariant(QLatin1String("extraValue2"))));
QVariantMap result = rmKit(map, QLatin1String("testId"));
if (result.count() != 4
|| !result.contains(QLatin1String("Profile.0"))
|| !result.contains(QLatin1String(COUNT))
|| result.value(QLatin1String(COUNT)).toInt() != 1
|| !result.contains(QLatin1String(DEFAULT))
|| result.value(QLatin1String(DEFAULT)).toInt() != 0
|| !result.contains(QLatin1String(VERSION))
|| result.value(QLatin1String(VERSION)).toInt() != 1)
return false;
result = rmKit(map, QLatin1String("unknown"));
if (result != map)
return false;
result = rmKit(map, QLatin1String("testId2"));
if (result.count() != 4
|| !result.contains(QLatin1String("Profile.0"))
|| !result.contains(QLatin1String(COUNT))
|| result.value(QLatin1String(COUNT)).toInt() != 1
|| !result.contains(QLatin1String(DEFAULT))
|| result.value(QLatin1String(DEFAULT)).toInt() != 0
|| !result.contains(QLatin1String(VERSION))
|| result.value(QLatin1String(VERSION)).toInt() != 1)
return false;
result = rmKit(result, QLatin1String("testId"));
if (result.count() != 3
|| !result.contains(QLatin1String(COUNT))
|| result.value(QLatin1String(COUNT)).toInt() != 0
|| !result.contains(QLatin1String(DEFAULT))
|| result.value(QLatin1String(DEFAULT)).toInt() != -1
|| !result.contains(QLatin1String(VERSION))
|| result.value(QLatin1String(VERSION)).toInt() != 1)
return false;
return true;
}
QVariantMap RmKitOperation::rmKit(const QVariantMap &map, const QString &id)
{
QVariantMap result = AddKitOperation::initializeKits();
QVariantList profileList;
bool ok;
int count = GetOperation::get(map, QLatin1String(COUNT)).toInt(&ok);
if (!ok) {
std::cerr << "Error: The count found in map is not an integer." << std::endl;
return map;
}
int kitPos = -1;
for (int i = 0; i < count; ++i) {
const QString key = QString::fromLatin1(PREFIX) + QString::number(i);
QVariantMap profile = map.value(key).toMap();
if (profile.value(QLatin1String(ID)).toString() == id) {
kitPos = i;
continue;
}
profileList << profile;
}
if (profileList.count() == map.count() - 3) {
std::cerr << "Error: Id was not found." << std::endl;
return map;
}
int defaultKit = GetOperation::get(map, QLatin1String(DEFAULT)).toInt(&ok);
if (!ok) {
std::cerr << "Error: Could not find the default kit." << std::endl;
defaultKit = -1;
}
if (defaultKit == kitPos || defaultKit < 0)
defaultKit = (count > 1) ? 0 : -1;
// remove data:
QStringList toRemove;
toRemove << QLatin1String(COUNT) << QLatin1String(DEFAULT);
result = RmKeysOperation::rmKeys(result, toRemove);
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << QLatin1String(DEFAULT), QVariant(defaultKit));
data << KeyValuePair(QStringList() << QLatin1String(COUNT), QVariant(count - 1));
for (int i = 0; i < profileList.count(); ++i)
data << KeyValuePair(QStringList() << QString::fromLatin1(PREFIX) + QString::number(i),
profileList.at(i));
return AddKeysOperation::addKeys(result, data);
}
QVariantMap AddDebuggerOperation::addDebugger(const QVariantMap &map,
const QString &id, const QString &displayName,
const quint32 &engine, const QString &binary,
const QStringList &abis, const KeyValuePairList &extra)
{
// Sanity check: Make sure autodetection source is not in use already:
QStringList valueKeys = FindValueOperation::findValue(map, QVariant(id));
bool hasId = false;
foreach (const QString &k, valueKeys) {
if (k.endsWith(QString(QLatin1Char('/')) + QLatin1String(ID))) {
hasId = true;
break;
}
}
if (hasId) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as debugger." << std::endl;
return QVariantMap();
}
// Find position to insert:
bool ok;
int count = GetOperation::get(map, QLatin1String(COUNT)).toInt(&ok);
if (!ok || count < 0) {
std::cerr << "Error: Count found in debuggers file seems wrong." << std::endl;
return QVariantMap();
}
const QString debugger = QString::fromLatin1(PREFIX) + QString::number(count);
// remove data:
QStringList toRemove;
toRemove << QLatin1String(COUNT);
QVariantMap cleaned = RmKeysOperation::rmKeys(map, toRemove);
// Sanity check: Make sure displayName is unique.
QStringList nameKeys = FindKeyOperation::findKey(map, QLatin1String(DISPLAYNAME));
QStringList nameList;
foreach (const QString &nameKey, nameKeys)
nameList << GetOperation::get(map, nameKey).toString();
const QString uniqueName = makeUnique(displayName, nameList);
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << debugger << QLatin1String(ID), QVariant(id));
data << KeyValuePair(QStringList() << debugger << QLatin1String(DISPLAYNAME), QVariant(uniqueName));
data << KeyValuePair(QStringList() << debugger << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ABIS), QVariant(abis));
data << KeyValuePair(QStringList() << debugger << QLatin1String(ENGINE_TYPE), QVariant(engine));
data << KeyValuePair(QStringList() << debugger << QLatin1String(BINARY), QVariant(binary));
data << KeyValuePair(QStringList() << QLatin1String(COUNT), QVariant(count + 1));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
qtExtraList << KeyValuePair(QStringList() << debugger << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(cleaned, data);
}
QVariantMap AddToolChainOperation::addToolChain(const QVariantMap &map,
const QString &id, const QString &displayName,
const QString &path, const QString &abi,
const QString &supportedAbis, const KeyValuePairList &extra)
{
// Sanity check: Does the Id already exist?
QStringList valueKeys = FindValueOperation::findValues(map, id);
bool hasId = false;
foreach (const QString &k, valueKeys) {
if (k.endsWith(QString(QLatin1Char('/')) + QLatin1String(ID))) {
hasId = true;
break;
}
}
if (hasId) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined for tool chains." << std::endl;
return QVariantMap();
}
// Find position to insert Tool Chain at:
bool ok;
int count = GetOperation::get(map, QLatin1String(COUNT)).toInt(&ok);
if (!ok || count < 0) {
std::cerr << "Error: Count found in toolchains file seems wrong." << std::endl;
return QVariantMap();
}
// Sanity check: Make sure displayName is unique.
QStringList nameKeys = FindKeyOperation::findKey(map, QLatin1String(DISPLAYNAME));
QStringList nameList;
foreach (const QString &nameKey, nameKeys)
nameList << GetOperation::get(map, nameKey).toString();
const QString uniqueName = makeUnique(displayName, nameList);
QVariantMap result = RmKeysOperation::rmKeys(map, QStringList() << QLatin1String(COUNT));
std::cout << "Registering ToolChain " << count << std::endl;
const QString tc = QString::fromLatin1(PREFIX) + QString::number(count);
KeyValuePairList data;
data << KeyValuePair(QStringList() << tc << QLatin1String(ID), QVariant(id.toUtf8()));
data << KeyValuePair(QStringList() << tc << QLatin1String(DISPLAYNAME), QVariant(uniqueName));
data << KeyValuePair(QStringList() << tc << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << tc << QLatin1String(PATH), QVariant(path));
data << KeyValuePair(QStringList() << tc << QLatin1String(TARGET_ABI), QVariant(abi));
QVariantList abis;
QStringList abiStrings = supportedAbis.split(QLatin1Char(','));
foreach (const QString &s, abiStrings)
abis << QVariant(s);
data << KeyValuePair(QStringList() << tc << QLatin1String(SUPPORTED_ABIS), QVariant(abis));
KeyValuePairList tcExtraList;
foreach (const KeyValuePair &pair, extra)
tcExtraList << KeyValuePair(QStringList() << tc << pair.key, pair.value);
data.append(tcExtraList);
data << KeyValuePair(QLatin1String(COUNT), QVariant(count + 1));
return AddKeysOperation::addKeys(result, data);
}
QVariantMap RmDebuggerOperation::rmDebugger(const QVariantMap &map, const QString &id)
{
QVariantMap result = AddDebuggerOperation::initializeDebuggers();
QVariantList debuggerList;
bool ok;
int count = GetOperation::get(map, QLatin1String(COUNT)).toInt(&ok);
if (!ok) {
std::cerr << "Error: The count found in map is not an integer." << std::endl;
return map;
}
for (int i = 0; i < count; ++i) {
const QString key = QString::fromLatin1(PREFIX) + QString::number(i);
QVariantMap debugger = map.value(key).toMap();
if (debugger.value(QLatin1String(ID)).toString() == id)
continue;
debuggerList << debugger;
}
if (debuggerList.count() == map.count() - 2) {
std::cerr << "Error: Id was not found." << std::endl;
return map;
}
// remove data:
QStringList toRemove;
toRemove << QLatin1String(COUNT);
result = RmKeysOperation::rmKeys(result, toRemove);
// insert data:
KeyValuePairList data;
data << KeyValuePair(QLatin1String(COUNT), count - 1);
for (int i = 0; i < debuggerList.count(); ++i) {
data << KeyValuePair(QStringList() << QString::fromLatin1(PREFIX) + QString::number(i),
debuggerList.at(i));
}
return AddKeysOperation::addKeys(result, data);
}
QVariantMap RmMerSdkOperation::removeSdk(const QVariantMap &map, const QString &sdkName)
{
QVariantMap result = AddMerSdkOperation::initializeSdks();
QVariantList sdkList;
bool ok;
int count = GetOperation::get(map, QLatin1String(Mer::Constants::MER_SDK_COUNT_KEY)).toInt(&ok);
if (!ok) {
std::cerr << "Error: The count found in map is not an integer." << std::endl;
return map;
}
for (int i = 0; i < count; ++i) {
const QString sdk = QString::fromLatin1(Mer::Constants::MER_SDK_DATA_KEY) + QString::number(i);
QVariantMap sdkMap = map.value(sdk).toMap();
if (sdkMap.value(QLatin1String(Mer::Constants::VM_NAME)).toString() == sdkName) {
continue;
}
sdkList << sdkMap;
}
if (sdkList.count() == map.count() - 2) {
std::cerr << "Error: Sdk was not found." << std::endl;
return map;
}
// remove data:
QStringList toRemove;
toRemove << QLatin1String(Mer::Constants::MER_SDK_COUNT_KEY);
result = RmKeysOperation::rmKeys(result, toRemove);
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << QLatin1String(Mer::Constants::MER_SDK_COUNT_KEY), QVariant(count - 1));
for (int i = 0; i < sdkList.count(); ++i)
data << KeyValuePair(QStringList() << QString::fromLatin1(Mer::Constants::MER_SDK_DATA_KEY) + QString::number(i),
sdkList.at(i));
return AddKeysOperation::addKeys(result, data);
}
QVariantMap AddQtOperation::addQt(const QVariantMap &map,
const QString &id, const QString &displayName, const QString &type,
const QString &qmake, const KeyValuePairList &extra)
{
QString sdkId = extendId(id);
// Sanity check: Make sure autodetection source is not in use already:
if (exists(map, sdkId)) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as Qt versions." << std::endl;
return QVariantMap();
}
// Find position to insert:
int versionCount = 0;
for (QVariantMap::const_iterator i = map.begin(); i != map.end(); ++i) {
if (!i.key().startsWith(QLatin1String(PREFIX)))
continue;
QString number = i.key().mid(QString::fromLatin1(PREFIX).count());
bool ok;
int count = number.toInt(&ok);
if (ok && count >= versionCount)
versionCount = count + 1;
}
const QString qt = QString::fromLatin1(PREFIX) + QString::number(versionCount);
// Sanity check: Make sure displayName is unique.
QStringList nameKeys = FindKeyOperation::findKey(map, QLatin1String(DISPLAYNAME));
QStringList nameList;
foreach (const QString &nameKey, nameKeys)
nameList << GetOperation::get(map, nameKey).toString();
const QString uniqueName = makeUnique(displayName, nameList);
// Sanitize qmake path:
QString saneQmake = QDir::cleanPath(QDir::fromNativeSeparators(qmake));
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << qt << QLatin1String(ID), QVariant(-1));
data << KeyValuePair(QStringList() << qt << QLatin1String(DISPLAYNAME), QVariant(uniqueName));
data << KeyValuePair(QStringList() << qt << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << qt << QLatin1String(AUTODETECTION_SOURCE), QVariant(sdkId));
data << KeyValuePair(QStringList() << qt << QLatin1String(QMAKE), QVariant(saneQmake));
data << KeyValuePair(QStringList() << qt << QLatin1String(TYPE), QVariant(type));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
qtExtraList << KeyValuePair(QStringList() << qt << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(map, data);
}
void FilePrefsSource::SetValue(const char* inKey, const char* inValue)
{
KeyValuePair* keyValue = NULL;
// If the key/value already exists update the value.
// If duplicate keys are allowed, however, add a new entry regardless
if ((!fAllowDuplicates) && ((keyValue = this->FindValue(inKey, NULL)) != NULL))
{
keyValue->ResetValue(inValue);
}
else
{
fKeyValueList = NEW KeyValuePair(inKey, inValue, fKeyValueList);
fNumKeys++;
}
}
bool RmToolChainOperation::test() const
{
// Add toolchain:
QVariantMap map = AddToolChainOperation::initializeToolChains();
map = AddToolChainOperation::addToolChain(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("/tmp/test"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
map = AddToolChainOperation::addToolChain(map, QLatin1String("testId2"), QLatin1String("other name"), QLatin1String("/tmp/test2"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList());
QVariantMap result = rmToolChain(QVariantMap(), QLatin1String("nonexistant"));
if (!result.isEmpty())
return false;
result = rmToolChain(map, QLatin1String("nonexistant"));
if (result != map)
return false;
result = rmToolChain(map, QLatin1String("testId2"));
if (result == map
|| result.value(QLatin1String(COUNT), 0).toInt() != 1
|| !result.contains(QLatin1String("ToolChain.0"))
|| result.value(QLatin1String("ToolChain.0")) != map.value(QLatin1String("ToolChain.0")))
return false;
result = rmToolChain(map, QLatin1String("testId"));
if (result == map
|| result.value(QLatin1String(COUNT), 0).toInt() != 1
|| !result.contains(QLatin1String("ToolChain.0"))
|| result.value(QLatin1String("ToolChain.0")) != map.value(QLatin1String("ToolChain.1")))
return false;
result = rmToolChain(result, QLatin1String("testId2"));
if (result == map
|| result.value(QLatin1String(COUNT), 0).toInt() != 0)
return false;
return true;
}
bool RmQtOperation::test() const
{
// Add toolchain:
QVariantMap map = AddQtOperation::initializeQtVersions();
QVariantMap result = rmQt(QVariantMap(), QLatin1String("nonexistant"));
if (result != map)
return false;
map = AddQtOperation::addQt(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("type"),
QLatin1String("/tmp/test"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
map = AddQtOperation::addQt(map, QLatin1String("testId2"), QLatin1String("other name"), QLatin1String("type"),
QLatin1String("/tmp/test2"),
KeyValuePairList());
result = rmQt(map, QLatin1String("nonexistant"));
if (result != map)
return false;
result = rmQt(map, QLatin1String("testId2"));
if (result == map
|| !result.contains(QLatin1String("QtVersion.0"))
|| result.value(QLatin1String("QtVersion.0")) != map.value(QLatin1String("QtVersion.0")))
return false;
result = rmQt(map, QLatin1String("testId"));
if (result == map
|| !result.contains(QLatin1String("QtVersion.0"))
|| result.value(QLatin1String("QtVersion.0")) != map.value(QLatin1String("QtVersion.1")))
return false;
result = rmQt(result, QLatin1String("testId2"));
if (result == map)
return false;
return true;
}
QVariantMap AddKitOperation::addKit(const QVariantMap &map, const QVariantMap &tcMap,
const QVariantMap &qtMap, const QVariantMap &devMap,
const QString &id, const QString &displayName,
const QString &icon, const QString &debuggerId,
const quint32 &debuggerType, const QString &debugger,
const QString &deviceType, const QString &device,
const QString &sysRoot, const QHash<QString, QString> &tcs, const QString &qt,
const QString &mkspec, const QStringList &env,
const KeyValuePairList &extra)
{
// Sanity check: Make sure autodetection source is not in use already:
QStringList valueKeys = FindValueOperation::findValue(map, QVariant(id));
bool hasId = false;
foreach (const QString &k, valueKeys) {
if (k.endsWith(QString('/') + ID)) {
hasId = true;
break;
}
}
if (hasId) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as kit." << std::endl;
return QVariantMap();
}
for (auto i = tcs.constBegin(); i != tcs.constEnd(); ++i) {
if (!i.value().isEmpty() && !AddToolChainOperation::exists(tcMap, i.value())) {
QRegExp abiRegExp = QRegExp("[a-z0-9_]+-[a-z0-9_]+-[a-z0-9_]+-[a-z0-9_]+-(8|16|32|64|128)bit");
if (!abiRegExp.exactMatch(i.value())) {
std::cerr << "Error: Toolchain " << qPrintable(i.value())
<< " for language " << qPrintable(i.key()) << " does not exist." << std::endl;
return QVariantMap();
}
}
}
QString qtId = qt;
if (!qtId.isEmpty() && !qtId.startsWith("SDK."))
qtId = QString::fromLatin1("SDK.") + qt;
if (!qtId.isEmpty() && !AddQtOperation::exists(qtMap, qtId)) {
std::cerr << "Error: Qt " << qPrintable(qtId) << " does not exist." << std::endl;
return QVariantMap();
}
if (!device.isEmpty() && !AddDeviceOperation::exists(devMap, device)) {
std::cerr << "Error: Device " << qPrintable(device) << " does not exist." << std::endl;
return QVariantMap();
}
// Find position to insert:
bool ok;
int count = GetOperation::get(map, COUNT).toInt(&ok);
if (!ok || count < 0) {
std::cerr << "Error: Count found in kits file seems wrong." << std::endl;
return QVariantMap();
}
const QString kit = QString::fromLatin1(PREFIX) + QString::number(count);
QString defaultKit = GetOperation::get(map, DEFAULT).toString();
if (defaultKit.isEmpty())
defaultKit = id;
// remove data:
QVariantMap cleaned = RmKeysOperation::rmKeys(map, { COUNT, DEFAULT });
// Sanity check: Make sure displayName is unique.
QStringList nameKeys = FindKeyOperation::findKey(map, DISPLAYNAME);
QStringList nameList;
foreach (const QString &nameKey, nameKeys)
nameList << GetOperation::get(map, nameKey).toString();
const QString uniqueName = makeUnique(displayName, nameList);
// insert data:
KeyValuePairList data = { KeyValuePair({ kit, ID }, QVariant(id)),
KeyValuePair({ kit, DISPLAYNAME }, QVariant(uniqueName)),
KeyValuePair({ kit, ICON }, QVariant(icon)),
KeyValuePair({ kit, AUTODETECTED }, QVariant(true)),
KeyValuePair({ kit, SDK }, QVariant(true)) };
if (!debuggerId.isEmpty() || !debugger.isEmpty()) {
if (debuggerId.isEmpty()) {
data << KeyValuePair({ kit, DATA, DEBUGGER, DEBUGGER_ENGINE }, QVariant(debuggerType));
data << KeyValuePair({ kit, DATA, DEBUGGER, DEBUGGER_BINARY }, QVariant(debugger));
} else {
data << KeyValuePair({ kit, DATA, DEBUGGER }, QVariant(debuggerId));
}
}
if (!deviceType.isNull())
data << KeyValuePair({ kit, DATA, DEVICE_TYPE }, QVariant(deviceType));
if (!device.isNull())
data << KeyValuePair({ kit, DATA, DEVICE_ID }, QVariant(device));
if (!sysRoot.isNull())
data << KeyValuePair({ kit, DATA, SYSROOT }, QVariant(sysRoot));
for (auto i = tcs.constBegin(); i != tcs.constEnd(); ++i)
data << KeyValuePair({ kit, DATA, TOOLCHAIN, i.key() }, QVariant(i.value()));
if (!qtId.isNull())
data << KeyValuePair({ kit, DATA, QT }, QVariant(qtId));
if (!mkspec.isNull())
data << KeyValuePair({ kit, DATA, MKSPEC }, QVariant(mkspec));
if (!env.isEmpty())
data << KeyValuePair({ kit, DATA, ENV }, QVariant(env));
data << KeyValuePair(DEFAULT, QVariant(defaultKit));
data << KeyValuePair(COUNT, QVariant(count + 1));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
qtExtraList << KeyValuePair(QStringList() << kit << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(cleaned, data);
}
bool AddKitOperation::test() const
{
QVariantMap map = initializeKits();
QVariantMap tcMap = AddToolChainOperation::initializeToolChains();
tcMap = AddToolChainOperation::addToolChain(tcMap, "{tc-id}", "langId", "TC", "/usr/bin/gcc",
"x86-linux-generic-elf-32bit",
"x86-linux-generic-elf-32bit",
KeyValuePairList());
QVariantMap qtMap = AddQtOperation::initializeQtVersions();
qtMap = AddQtOperation::addQt(qtMap, "{qt-id}", "Qt", "desktop-qt", "/usr/bin/qmake",
KeyValuePairList());
QVariantMap devMap = AddDeviceOperation::initializeDevices();
devMap = AddDeviceOperation::addDevice(devMap, "{dev-id}", "Dev", 0, 0,
"HWplatform", "SWplatform",
"localhost", "10000-11000",
"localhost", "", 42,
"desktop", "", 22, 10000,
"uname", 1,
KeyValuePairList());
const QStringList env = { "TEST=1", "PATH" };
if (map.count() != 3
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
|| !map.contains(COUNT) || map.value(COUNT).toInt() != 0
|| !map.contains(DEFAULT) || !map.value(DEFAULT).toString().isEmpty())
return false;
QHash<QString, QString> tcs;
tcs.insert("Cxx", "{tcXX-id}");
// Fail if TC is not there:
QVariantMap empty = addKit(map, tcMap, qtMap, devMap,
"testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec", QStringList(),
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (!empty.isEmpty())
return false;
// Do not fail if TC is an ABI:
tcs.clear();
tcs.insert("C", "x86-linux-generic-elf-64bit");
empty = addKit(map, tcMap, qtMap, devMap, "testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (empty.isEmpty())
return false;
// QTCREATORBUG-11983, mach_o was not covered by the first attempt to fix this.
tcs.insert("D", "x86-macos-generic-mach_o-64bit");
empty = addKit(map, tcMap, qtMap, devMap, "testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(),
tcs, "{qt-id}", "unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (empty.isEmpty())
return false;
tcs.clear();
tcs.insert("Cxx", "{tc-id}");
// Fail if Qt is not there:
empty = addKit(map, tcMap, qtMap, devMap, "testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{dev-id}", QString(), tcs, "{qtXX-id}",
"unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (!empty.isEmpty())
return false;
// Fail if dev is not there:
empty = addKit(map, tcMap, qtMap, devMap, "testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", "{devXX-id}", QString(), tcs, "{qt-id}",
"unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (!empty.isEmpty())
return false;
// Profile 0:
map = addKit(map, tcMap, qtMap, devMap, "testId", "Test Kit", "/tmp/icon.png", QString(), 1,
"/usr/bin/gdb-test", "Desktop", QString(), QString(), tcs, "{qt-id}",
"unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (map.count() != 4
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
|| !map.contains(COUNT) || map.value(COUNT).toInt() != 1
|| !map.contains(DEFAULT) || map.value(DEFAULT).toString() != "testId"
|| !map.contains("Profile.0"))
return false;
QVariantMap profile0 = map.value("Profile.0").toMap();
if (profile0.count() != 6
|| !profile0.contains(ID) || profile0.value(ID).toString() != "testId"
|| !profile0.contains(DISPLAYNAME) || profile0.value(DISPLAYNAME).toString() != "Test Kit"
|| !profile0.contains(ICON) || profile0.value(ICON).toString() != "/tmp/icon.png"
|| !profile0.contains(DATA) || profile0.value(DATA).type() != QVariant::Map
|| !profile0.contains(AUTODETECTED) || profile0.value(AUTODETECTED).toBool() != true
|| !profile0.contains(SDK) || profile0.value(SDK).toBool() != true)
return false;
QVariantMap data = profile0.value(DATA).toMap();
if (data.count() != 7
|| !data.contains(DEBUGGER) || data.value(DEBUGGER).type() != QVariant::Map
|| !data.contains(DEVICE_TYPE) || data.value(DEVICE_TYPE).toString() != "Desktop"
|| !data.contains(TOOLCHAIN)
|| !data.contains(QT) || data.value(QT).toString() != "SDK.{qt-id}"
|| !data.contains(MKSPEC) || data.value(MKSPEC).toString() != "unsupported/mkspec"
|| !data.contains("extraData") || data.value("extraData").toString() != "extraValue")
return false;
QVariantMap tcOutput = data.value(TOOLCHAIN).toMap();
if (tcOutput.count() != 1
|| !tcOutput.contains("Cxx") || tcOutput.value("Cxx") != "{tc-id}")
return false;
// Ignore existing ids:
QVariantMap result = addKit(map, tcMap, qtMap, devMap, "testId", "Test Qt Version X",
"/tmp/icon3.png", QString(), 1, "/usr/bin/gdb-test3", "Desktop",
QString(), QString(), tcs, "{qt-id}", "unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (!result.isEmpty())
return false;
// Profile 1: Make sure name is unique:
map = addKit(map, tcMap, qtMap, devMap, "testId2", "Test Kit2", "/tmp/icon2.png", QString(), 1,
"/usr/bin/gdb-test2", "Desktop", "{dev-id}", "/sys/root\\\\", tcs,
"{qt-id}", "unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (map.count() != 5
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
|| !map.contains(COUNT) || map.value(COUNT).toInt() != 2
|| !map.contains(DEFAULT) || map.value(DEFAULT).toInt() != 0
|| !map.contains("Profile.0")
|| !map.contains("Profile.1"))
if (map.value("Profile.0") != profile0)
return false;
QVariantMap profile1 = map.value("Profile.1").toMap();
if (profile1.count() != 6
|| !profile1.contains(ID) || profile1.value(ID).toString() != "testId2"
|| !profile1.contains(DISPLAYNAME) || profile1.value(DISPLAYNAME).toString() != "Test Kit2"
|| !profile1.contains(ICON) || profile1.value(ICON).toString() != "/tmp/icon2.png"
|| !profile1.contains(DATA) || profile1.value(DATA).type() != QVariant::Map
|| !profile1.contains(AUTODETECTED) || profile1.value(AUTODETECTED).toBool() != true
|| !profile1.contains(SDK) || profile1.value(SDK).toBool() != true)
return false;
data = profile1.value(DATA).toMap();
if (data.count() != 9
|| !data.contains(DEBUGGER) || data.value(DEBUGGER).type() != QVariant::Map
|| !data.contains(DEVICE_TYPE) || data.value(DEVICE_TYPE).toString() != "Desktop"
|| !data.contains(DEVICE_ID) || data.value(DEVICE_ID).toString() != "{dev-id}"
|| !data.contains(SYSROOT) || data.value(SYSROOT).toString() != "/sys/root\\\\"
|| !data.contains(TOOLCHAIN)
|| !data.contains(QT) || data.value(QT).toString() != "SDK.{qt-id}"
|| !data.contains(MKSPEC) || data.value(MKSPEC).toString() != "unsupported/mkspec"
|| !data.contains(ENV) || data.value(ENV).toStringList() != env
|| !data.contains("extraData") || data.value("extraData").toString() != "extraValue")
return false;
tcOutput = data.value(TOOLCHAIN).toMap();
if (tcOutput.count() != 1
|| !tcOutput.contains("Cxx") || tcOutput.value("Cxx") != "{tc-id}")
return false;
// Profile 2: Test debugger id:
map = addKit(map, tcMap, qtMap, devMap, "test with debugger Id", "Test debugger Id",
"/tmp/icon2.png", "debugger Id", 0, QString(), "Desktop", QString(), QString(),
tcs, "{qt-id}", "unsupported/mkspec", env,
KeyValuePairList({ KeyValuePair("PE.Profile.Data/extraData", QVariant("extraValue")) }));
if (map.count() != 6
|| !map.contains(VERSION) || map.value(VERSION).toInt() != 1
|| !map.contains(COUNT) || map.value(COUNT).toInt() != 3
|| !map.contains(DEFAULT) || map.value(DEFAULT).toInt() != 0
|| !map.contains("Profile.0")
|| !map.contains("Profile.1")
|| !map.contains("Profile.2"))
if (map.value("Profile.0") != profile0)
return false;
if (map.value("Profile.1") != profile1)
return false;
QVariantMap profile2 = map.value("Profile.2").toMap();
if (profile2.count() != 6
|| !profile2.contains(ID) || profile2.value(ID).toString() != "test with debugger Id"
|| !profile2.contains(DISPLAYNAME) || profile2.value(DISPLAYNAME).toString() != "Test debugger Id"
|| !profile2.contains(ICON) || profile2.value(ICON).toString() != "/tmp/icon2.png"
|| !profile2.contains(DATA) || profile2.value(DATA).type() != QVariant::Map
|| !profile2.contains(AUTODETECTED) || profile2.value(AUTODETECTED).toBool() != true
|| !profile2.contains(SDK) || profile2.value(SDK).toBool() != true)
return false;
data = profile2.value(DATA).toMap();
if (data.count() != 7
|| !data.contains(DEBUGGER) || data.value(DEBUGGER).toString() != "debugger Id")
return false;
return true;
}
/**
* Places a given key, and it's corresponding value into flash at the earliest
* available point.
*
* @param key the unique name that should be used as an identifier for the given data.
* The key is presumed to be null terminated.
*
* @param data a pointer to the beginning of the data to be persisted.
*
* @return MICROBIT_OK on success, or MICROBIT_NO_RESOURCES if the storage page is full
*/
int MicroBitStorage::put(const char *key, uint8_t *data)
{
KeyValuePair pair = KeyValuePair();
memcpy(pair.key, key, min(sizeof(pair.key), strlen(key)));
memcpy(pair.value, data, sizeof(pair.value));
//calculate our various offsets.
uint32_t pg_size = NRF_FICR->CODEPAGESIZE;
uint32_t *flashPointer = (uint32_t *)(pg_size * (NRF_FICR->CODESIZE - MICROBIT_STORAGE_STORE_PAGE_OFFSET));
uint32_t *flashBlockPointer = flashPointer;
uint32_t *scratchPointer = (uint32_t *)(pg_size * (NRF_FICR->CODESIZE - MICROBIT_STORAGE_SCRATCH_PAGE_OFFSET));
uint32_t kvStoreSize = sizeof(KeyValueStore) / 4;
uint32_t kvPairSize = sizeof(KeyValuePair) / 4;
int storeSize = size();
//our KeyValueStore struct is always at 0
flashPointer += kvStoreSize;
KeyValuePair storedPair = KeyValuePair();
int found = 0;
//erase our scratch page
flashPageErase(scratchPointer);
//iterate through key value pairs in flash, writing them to the scratch page.
for(int i = 0; i < storeSize; i++)
{
memcpy(&storedPair, flashPointer, sizeof(KeyValuePair));
//check if the keys match...
if(strcmp((char *)storedPair.key, (char *)pair.key) == 0)
{
found = 1;
//scratch our KeyValueStore struct so that it is preserved.
scratchKeyValueStore(KeyValueStore(MICROBIT_STORAGE_MAGIC, storeSize));
scratchKeyValuePair(pair, flashPointer);
}
else
{
scratchKeyValuePair(storedPair, flashPointer);
}
flashPointer += kvPairSize;
}
if(!found)
{
//if we haven't got a match for the key, check we can add a new KeyValuePair
if(storeSize == (int)((pg_size - kvStoreSize) / MICROBIT_STORAGE_BLOCK_SIZE))
return MICROBIT_NO_RESOURCES;
storeSize += 1;
//scratch our updated values.
scratchKeyValueStore(KeyValueStore(MICROBIT_STORAGE_MAGIC, storeSize));
scratchKeyValuePair(pair, flashPointer);
}
//erase our storage page
flashPageErase((uint32_t *)flashBlockPointer);
//copy from scratch to storage.
flashCopy((uint32_t *)(pg_size * (NRF_FICR->CODESIZE - MICROBIT_STORAGE_SCRATCH_PAGE_OFFSET)), flashBlockPointer, kvStoreSize + (storeSize * kvPairSize));
return MICROBIT_OK;
}
/**
* Removes a KeyValuePair identified by a given key.
*
* @param key the unique name used to identify a KeyValuePair in flash.
*
* @return MICROBIT_OK on success, or MICROBIT_NO_DATA if the given key
* was not found in flash.
*/
int MicroBitStorage::remove(const char* key)
{
//calculate our various offsets
uint32_t pg_size = NRF_FICR->CODEPAGESIZE;
uint32_t *flashPointer = (uint32_t *)(pg_size * (NRF_FICR->CODESIZE - MICROBIT_STORAGE_STORE_PAGE_OFFSET));
uint32_t *flashBlockPointer = flashPointer;
uint32_t *scratchPointer = (uint32_t *)(pg_size * (NRF_FICR->CODESIZE - MICROBIT_STORAGE_SCRATCH_PAGE_OFFSET));
uint32_t kvStoreSize = sizeof(KeyValueStore) / 4;
uint32_t kvPairSize = sizeof(KeyValuePair) / 4;
int storeSize = size();
//if we have no data, we have nothing to do.
if(storeSize == 0)
return MICROBIT_NO_DATA;
//our KeyValueStore struct is always at 0
flashPointer += kvStoreSize;
scratchPointer += kvStoreSize;
KeyValuePair storedPair = KeyValuePair();
int found = 0;
//set up our scratch area
flashPageErase(scratchPointer);
//iterate through our flash copy pairs to scratch, unless there is a key patch
for(int i = 0; i < storeSize; i++)
{
memcpy(&storedPair, flashPointer, sizeof(KeyValuePair));
//if we have a match, don't increment our scratchPointer
if(strcmp((char *)storedPair.key, (char *)key) == 0)
{
found = 1;
//write our new KeyValueStore data
scratchKeyValueStore(KeyValueStore(MICROBIT_STORAGE_MAGIC, storeSize - 1));
}
else
{
//otherwise copy the KeyValuePair from our storage page.
flashCopy(flashPointer, scratchPointer, sizeof(KeyValuePair) / 4);
scratchPointer += sizeof(KeyValuePair) / 4;
}
flashPointer += sizeof(KeyValuePair) / 4;
}
//if we haven't got a match, write our old KeyValueStore struct
if(!found)
{
scratchKeyValueStore(KeyValueStore(MICROBIT_STORAGE_MAGIC, storeSize));
return MICROBIT_NO_DATA;
}
//copy scratch to our storage page
flashPageErase((uint32_t *)flashBlockPointer);
flashCopy((uint32_t *)(pg_size * (NRF_FICR->CODESIZE - MICROBIT_STORAGE_SCRATCH_PAGE_OFFSET)), flashBlockPointer, kvStoreSize + (storeSize * kvPairSize));
return MICROBIT_OK;
}
bool AddQtOperation::test() const
{
QVariantMap map = initializeQtVersions();
if (map.count() != 1
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1)
return false;
#if defined Q_OS_WIN
map = addQt(map, QLatin1String("testId"), QLatin1String("Test Qt Version"), QLatin1String("testType"),
QLatin1String("/tmp//../tmp/test\\qmake"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))));
#else
map = addQt(map, QLatin1String("testId"), QLatin1String("Test Qt Version"), QLatin1String("testType"),
QLatin1String("/tmp//../tmp/test/qmake"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))));
#endif
if (map.count() != 2
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1
|| !map.contains(QLatin1String("QtVersion.0")))
return false;
QVariantMap version0 = map.value(QLatin1String("QtVersion.0")).toMap();
if (version0.count() != 7
|| !version0.contains(QLatin1String(ID))
|| version0.value(QLatin1String(ID)).toInt() != -1
|| !version0.contains(QLatin1String(DISPLAYNAME))
|| version0.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("Test Qt Version")
|| !version0.contains(QLatin1String(AUTODETECTED))
|| version0.value(QLatin1String(AUTODETECTED)).toBool() != true
|| !version0.contains(QLatin1String(AUTODETECTION_SOURCE))
|| version0.value(QLatin1String(AUTODETECTION_SOURCE)).toString() != QLatin1String("SDK.testId")
|| !version0.contains(QLatin1String(TYPE))
|| version0.value(QLatin1String(TYPE)).toString() != QLatin1String("testType")
|| !version0.contains(QLatin1String(QMAKE))
|| version0.value(QLatin1String(QMAKE)).toString() != QLatin1String("/tmp/test/qmake")
|| !version0.contains(QLatin1String("extraData"))
|| version0.value(QLatin1String("extraData")).toString() != QLatin1String("extraValue"))
return false;
// Ignore existing ids:
QVariantMap result = addQt(map, QLatin1String("testId"), QLatin1String("Test Qt Version2"), QLatin1String("testType2"),
QLatin1String("/tmp/test/qmake2"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))));
if (!result.isEmpty())
return false;
// Make sure name is unique:
map = addQt(map, QLatin1String("testId2"), QLatin1String("Test Qt Version"), QLatin1String("testType3"),
QLatin1String("/tmp/test/qmake2"),
KeyValuePairList() << KeyValuePair(QLatin1String("extraData"), QVariant(QLatin1String("extraValue"))));
if (map.count() != 3
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1
|| !map.contains(QLatin1String("QtVersion.0"))
|| !map.contains(QLatin1String("QtVersion.1")))
return false;
if (map.value(QLatin1String("QtVersion.0")) != version0)
return false;
QVariantMap version1 = map.value(QLatin1String("QtVersion.1")).toMap();
if (version1.count() != 7
|| !version1.contains(QLatin1String(ID))
|| version1.value(QLatin1String(ID)).toInt() != -1
|| !version1.contains(QLatin1String(DISPLAYNAME))
|| version1.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("Test Qt Version2")
|| !version1.contains(QLatin1String(AUTODETECTED))
|| version1.value(QLatin1String(AUTODETECTED)).toBool() != true
|| !version1.contains(QLatin1String(AUTODETECTION_SOURCE))
|| version1.value(QLatin1String(AUTODETECTION_SOURCE)).toString() != QLatin1String("SDK.testId2")
|| !version1.contains(QLatin1String(TYPE))
|| version1.value(QLatin1String(TYPE)).toString() != QLatin1String("testType3")
|| !version1.contains(QLatin1String(QMAKE))
|| version1.value(QLatin1String(QMAKE)).toString() != QLatin1String("/tmp/test/qmake2")
|| !version1.contains(QLatin1String("extraData"))
|| version1.value(QLatin1String("extraData")).toString() != QLatin1String("extraValue"))
return false;
return true;
}
bool AddKeysOperation::test() const
{
QVariantMap testMap;
QVariantMap subKeys;
subKeys.insert(QLatin1String("subsubkeys"), QVariantMap());
subKeys.insert(QLatin1String("testbool"), true);
testMap.insert(QLatin1String("subkeys"), subKeys);
subKeys.clear();
testMap.insert(QLatin1String("subkeys2"), subKeys);
testMap.insert(QLatin1String("testint"), 23);
KeyValuePairList data;
data.append(KeyValuePair(QLatin1String("bool-true"), QString::fromLatin1("bool:trUe")));
data.append(KeyValuePair(QLatin1String("bool-false"), QString::fromLatin1("bool:false")));
data.append(KeyValuePair(QLatin1String("int"), QString::fromLatin1("int:42")));
data.append(KeyValuePair(QLatin1String("qstring"), QString::fromLatin1("QString:test string.")));
data.append(KeyValuePair(QLatin1String("qbytearray"), QString::fromLatin1("QByteArray:test array.")));
data.append(KeyValuePair(QLatin1String("subkeys/qbytearray"), QString::fromLatin1("QByteArray:test array.")));
data.append(KeyValuePair(QLatin1String("subkeys/newsubkeys/qbytearray"), QString::fromLatin1("QByteArray:test array.")));
data.append(KeyValuePair(QLatin1String("newsub/1/2/3/qbytearray"), QString::fromLatin1("QByteArray:test array.")));
data.append(KeyValuePair(QLatin1String("newsub/1/2.1/3/qbytearray"), QString::fromLatin1("QByteArray:test array.")));
QVariantMap result = addKeys(testMap, data);
if (result.count() != 9)
return false;
// subkeys:
QVariantMap cur = result.value(QLatin1String("subkeys")).toMap();
if (cur.count() != 4
|| !cur.contains(QLatin1String("qbytearray"))
|| !cur.contains(QLatin1String("testbool"))
|| !cur.contains(QLatin1String("subsubkeys"))
|| !cur.contains(QLatin1String("newsubkeys")))
return false;
// subkeys/newsubkeys:
QVariantMap tmp = cur;
cur = cur.value(QLatin1String("newsubkeys")).toMap();
if (cur.count() != 1
|| !cur.contains(QLatin1String("qbytearray")))
return false;
// subkeys/subsubkeys:
cur = tmp.value(QLatin1String("subsubkeys")).toMap();
if (cur.count() != 0)
return false;
// newsub:
cur = result.value(QLatin1String("newsub")).toMap();
if (cur.count() != 1
|| !cur.contains(QLatin1String("1")))
return false;
// newsub/1:
cur = cur.value(QLatin1String("1")).toMap();
if (cur.count() != 2
|| !cur.contains(QLatin1String("2"))
|| !cur.contains(QLatin1String("2.1")))
return false;
// newsub/1/2:
tmp = cur;
cur = cur.value(QLatin1String("2")).toMap();
if (cur.count() != 1
|| !cur.contains(QLatin1String("3")))
return false;
// newsub/1/2/3:
cur = cur.value(QLatin1String("3")).toMap();
if (cur.count() != 1
|| !cur.contains(QLatin1String("qbytearray")))
return false;
// newsub/1/2.1:
cur = tmp.value(QLatin1String("2.1")).toMap();
if (cur.count() != 1
|| !cur.contains(QLatin1String("3")))
return false;
// newsub/1/2.1/3:
cur = cur.value(QLatin1String("3")).toMap();
if (cur.count() != 1
|| !cur.contains(QLatin1String("qbytearray")))
return false;
// subkeys2:
cur = result.value(QLatin1String("subkeys2")).toMap();
if (cur.count() != 0)
return false;
// values:
if (!result.contains(QLatin1String("bool-true")) || !result.value(QLatin1String("bool-true")).toBool())
return false;
if (!result.contains(QLatin1String("bool-false")) || result.value(QLatin1String("bool-false")).toBool())
return false;
if (!result.contains(QLatin1String("int")) || result.value(QLatin1String("int")).toInt() != 42)
return false;
if (!result.contains(QLatin1String("qstring"))
|| result.value(QLatin1String("qstring")).toString() != QLatin1String("test string."))
return false;
if (!result.contains(QLatin1String("qbytearray"))
|| result.value(QLatin1String("qbytearray")).toByteArray() != "test array.")
return false;
// Make sure we do not overwrite data:
// preexisting:
data.clear();
data.append(KeyValuePair(QLatin1String("testint"), QString::fromLatin1("int:4")));
result = addKeys(testMap, data);
if (!result.isEmpty())
return false;
data.clear();
data.append(KeyValuePair(QLatin1String("subkeys/testbool"), QString::fromLatin1("int:24")));
result = addKeys(testMap, data);
if (!result.isEmpty())
return false;
// data inserted before:
data.clear();
data.append(KeyValuePair(QLatin1String("bool-true"), QString::fromLatin1("bool:trUe")));
data.append(KeyValuePair(QLatin1String("bool-true"), QString::fromLatin1("bool:trUe")));
result = addKeys(testMap, data);
if (!result.isEmpty())
return false;
return true;
}
int main(int argc, const char * argv[]) {
//Create the root node of the tree:
KeyValuePair root_pair = KeyValuePair(8, "Node H");
TreeNode root = TreeNode(root_pair);
//add some nodes to our tree
TreeNode* node_a = new TreeNode(1, "Node A");
TreeNode* node_i = new TreeNode(9, "Node I");
TreeNode* node_b = new TreeNode(2, "Node B");
TreeNode* node_j = new TreeNode(10, "Node J");
root.setLeftChild(node_a);
root.setRightChild(node_i);
node_a->setRightChild(node_b);
node_i->setRightChild(node_j);
//------------------------------------------
// 1) Test the tree traversals:
std::cout << "-------------------" << std::endl;
std::cout << "Inorder Traversal:" << std::endl;
root.printInOrder();
std::cout << std::endl;
std::cout << "-------------------" << std::endl;
std::cout << std::endl;
std::cout << "-------------------" << std::endl;
std::cout << "Preorder Traversal:" << std::endl;
root.printPreOrder();
std::cout << std::endl;
std::cout << "-------------------" << std::endl;
std::cout << std::endl;
std::cout << "-------------------" << std::endl;
std::cout << "Postorder Traversal:" << std::endl;
root.printPostOrder();
std::cout << std::endl;
std::cout << "-------------------" << std::endl;
std::cout << std::endl;
//------------------------------------------
// 2) Test the searchkey function by searching for keys
std::cout << "Searching: " << std::endl;
std::cout << "-------------------" << std::endl;
TreeNode* my_node_pntr = root.searchKey(10);
std::cout << "Search for key 10 found: " << my_node_pntr->getPair()->getValue() << std::endl; //output should be Node J
my_node_pntr = root.searchKey(3);
std::cout << "Search for key 3 found: " << my_node_pntr->getPair()->getValue() << std::endl; // output should be Node B (because 3 isnt in the tree)
//------------------------------------------
// 3) Test the add method by creating new keyvaluepairs and adding them to the tree
// and after that, print again the inorder traversal, to see if the new nodes were added
std::cout << std::endl;
KeyValuePair* my_pair_pointer = new KeyValuePair(12, "Node L");
KeyValuePair* my_scnd_pair_pntr = new KeyValuePair(0, "Node 0");
root.add(my_pair_pointer);
root.add(my_scnd_pair_pntr);
std::cout << "updated Tree in inorder traversal:" << std::endl;
std::cout << "-------------------" << std::endl;
root.printInOrder();
//------------------------------------------
return 0;
}
QVariantMap AddMerSdkOperation::addSdk(const QVariantMap &map,
const QString &sdkName,
bool autodetected,
const QString &sharedHomePath,
const QString &sharedTargetsPath,
const QString &sharedSshPath,
const QString &sharedSrcPath,
const QString &sharedConfigPath,
const QString &host,
const QString &userName,
const QString &privateKeyFile,
quint16 sshPort,
quint16 wwwPort,
bool headless)
{
QStringList valueKeys = FindValueOperation::findValues(map, QVariant(sdkName));
bool hasTarget = false;
foreach (const QString &t, valueKeys) {
if (t.endsWith(QLatin1Char('/') + QLatin1String(Mer::Constants::VM_NAME))) {
hasTarget = true;
break;
}
}
if (hasTarget) {
std::cerr << "Error: Name " << qPrintable(sdkName) << " already defined as sdk." << std::endl;
return QVariantMap();
}
bool ok;
const int count = GetOperation::get(map, QLatin1String(Mer::Constants::MER_SDK_COUNT_KEY)).toInt(&ok);
if (!ok || count < 0) {
std::cerr << "Error: Count found sdks, file seems wrong." << std::endl;
return QVariantMap();
}
const QString sdk = QString::fromLatin1(Mer::Constants::MER_SDK_DATA_KEY) + QString::number(count);
// remove old count
QVariantMap cleaned = RmKeysOperation::rmKeys(map, QStringList() << QLatin1String(Mer::Constants::MER_SDK_COUNT_KEY));
KeyValuePairList data;
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::VM_NAME), QVariant(sdkName));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::AUTO_DETECTED), QVariant(autodetected));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::SHARED_HOME), QVariant(sharedHomePath));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::SHARED_TARGET), QVariant(sharedTargetsPath));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::SHARED_SSH), QVariant(sharedSshPath));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::SHARED_SRC), QVariant(sharedSrcPath));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::SHARED_CONFIG), QVariant(sharedConfigPath));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::HOST), QVariant(host));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::USERNAME), QVariant(userName));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::PRIVATE_KEY_FILE), QVariant(privateKeyFile));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::SSH_PORT), QVariant(sshPort));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::WWW_PORT), QVariant(wwwPort));
data << KeyValuePair(QStringList() << sdk << QLatin1String(Mer::Constants::HEADLESS), QVariant(headless));
data << KeyValuePair(QStringList() << QLatin1String(Mer::Constants::MER_SDK_COUNT_KEY), QVariant(count + 1));
return AddKeysOperation::addKeys(cleaned, data);
}
QVariantMap AddKitOperation::addKit(const QVariantMap &map,
const QString &id, const QString &displayName, const QString &icon,
const quint32 &debuggerType, const QString &debugger,
const QByteArray &deviceType, const QString &sysRoot,
const QString &tc, const QString &qt, const QString &mkspec,
const KeyValuePairList &extra)
{
// Sanity check: Make sure autodetection source is not in use already:
QStringList valueKeys = FindValueOperation::findValues(map, QVariant(id));
bool hasId = false;
foreach (const QString &k, valueKeys) {
if (k.endsWith(QString(QLatin1Char('/')) + QLatin1String(ID))) {
hasId = true;
break;
}
}
if (hasId) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as kit." << std::endl;
return QVariantMap();
}
// Find position to insert:
bool ok;
int count = GetOperation::get(map, QLatin1String(COUNT)).toInt(&ok);
if (!ok || count < 0) {
std::cerr << "Error: Count found in kits file seems wrong." << std::endl;
return QVariantMap();
}
const QString kit = QString::fromLatin1(PREFIX) + QString::number(count);
int defaultKit = GetOperation::get(map, QLatin1String(DEFAULT)).toInt(&ok);
if (!ok) {
std::cerr << "Error: Default kit seems wrong." << std::endl;
return QVariantMap();
}
if (defaultKit < 0)
defaultKit = 0;
// remove data:
QStringList toRemove;
toRemove << QLatin1String(COUNT) << QLatin1String(DEFAULT);
QVariantMap cleaned = RmKeysOperation::rmKeys(map, toRemove);
// Sanity check: Make sure displayName is unique.
QStringList nameKeys = FindKeyOperation::findKey(map, QLatin1String(DISPLAYNAME));
QStringList nameList;
foreach (const QString nameKey, nameKeys)
nameList << GetOperation::get(map, nameKey).toString();
const QString uniqueName = makeUnique(displayName, nameList);
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << kit << QLatin1String(ID), QVariant(id));
data << KeyValuePair(QStringList() << kit << QLatin1String(DISPLAYNAME), QVariant(uniqueName));
data << KeyValuePair(QStringList() << kit << QLatin1String(ICON), QVariant(icon));
data << KeyValuePair(QStringList() << kit << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA)
<< QLatin1String(DEBUGGER) << QLatin1String(DEBUGGER_ENGINE), QVariant(debuggerType));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA)
<< QLatin1String(DEBUGGER) << QLatin1String(DEBUGGER_BINARY), QVariant(debugger));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA) << DEVICE_TYPE, QVariant(deviceType));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA) << SYSROOT, QVariant(sysRoot));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA) << TOOLCHAIN, QVariant(tc));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA) << QT, QVariant(qt));
data << KeyValuePair(QStringList() << kit << QLatin1String(DATA) << MKSPEC, QVariant(mkspec));
data << KeyValuePair(QStringList() << QLatin1String(DEFAULT), QVariant(defaultKit));
data << KeyValuePair(QStringList() << QLatin1String(COUNT), QVariant(count + 1));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
qtExtraList << KeyValuePair(QStringList() << kit << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(cleaned, data);
}
bool AddKitOperation::test() const
{
QVariantMap map = initializeKits();
if (map.count() != 3
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1
|| !map.contains(QLatin1String(COUNT))
|| map.value(QLatin1String(COUNT)).toInt() != 0
|| !map.contains(QLatin1String(DEFAULT))
|| map.value(QLatin1String(DEFAULT)).toInt() != -1)
return false;
map = addKit(map, QLatin1String("testId"), QLatin1String("Test Kit"), QLatin1String("/tmp/icon.png"),
1, QLatin1String("/usr/bin/gdb-test"),
QByteArray("Desktop"), QString(),
QLatin1String("{some-tc-id}"), QLatin1String("{some-qt-id}"), QLatin1String("unsupported/mkspec"),
KeyValuePairList() << KeyValuePair(QLatin1String("PE.Profile.Data/extraData"), QVariant(QLatin1String("extraValue"))));
if (map.count() != 4
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1
|| !map.contains(QLatin1String(COUNT))
|| map.value(QLatin1String(COUNT)).toInt() != 1
|| !map.contains(QLatin1String(DEFAULT))
|| map.value(QLatin1String(DEFAULT)).toInt() != 0
|| !map.contains(QLatin1String("Profile.0")))
return false;
QVariantMap profile0 = map.value(QLatin1String("Profile.0")).toMap();
if (profile0.count() != 5
|| !profile0.contains(QLatin1String(ID))
|| profile0.value(QLatin1String(ID)).toString() != QLatin1String("testId")
|| !profile0.contains(QLatin1String(DISPLAYNAME))
|| profile0.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("Test Kit")
|| !profile0.contains(QLatin1String(AUTODETECTED))
|| profile0.value(QLatin1String(AUTODETECTED)).toBool() != true)
return false;
// Ignore existing ids:
QVariantMap result = addKit(map, QLatin1String("testId"), QLatin1String("Test Qt Version X"), QLatin1String("/tmp/icon3.png"),
1, QLatin1String("/usr/bin/gdb-test3"),
QByteArray("Desktop"), QString(),
QLatin1String("{some-tc-id3}"), QLatin1String("{some-qt-id3}"), QLatin1String("unsupported/mkspec3"),
KeyValuePairList() << KeyValuePair(QLatin1String("PE.Profile.Data/extraData"), QVariant(QLatin1String("extraValue3"))));
if (!result.isEmpty())
return false;
// Make sure name is unique:
map = addKit(map, QLatin1String("testId2"), QLatin1String("Test Kit2"), QLatin1String("/tmp/icon2.png"),
1, QLatin1String("/usr/bin/gdb-test2"),
QByteArray("Desktop"), QString(),
QLatin1String("{some-tc-id2}"), QLatin1String("{some-qt-id2}"), QLatin1String("unsupported/mkspec2"),
KeyValuePairList() << KeyValuePair(QLatin1String("PE.Profile.Data/extraData"), QVariant(QLatin1String("extraValue2"))));
if (map.count() != 5
|| !map.contains(QLatin1String(VERSION))
|| map.value(QLatin1String(VERSION)).toInt() != 1
|| !map.contains(QLatin1String(COUNT))
|| map.value(QLatin1String(COUNT)).toInt() != 2
|| !map.contains(QLatin1String(DEFAULT))
|| map.value(QLatin1String(DEFAULT)).toInt() != 0
|| !map.contains(QLatin1String("Profile.0"))
|| !map.contains(QLatin1String("Profile.1")))
if (map.value(QLatin1String("Profile.0")) != profile0)
return false;
QVariantMap profile1 = map.value(QLatin1String("Profile.1")).toMap();
if (profile1.count() != 5
|| !profile1.contains(QLatin1String(ID))
|| profile1.value(QLatin1String(ID)).toString() != QLatin1String("testId2")
|| !profile1.contains(QLatin1String(DISPLAYNAME))
|| profile1.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("Test Kit2")
|| !profile1.contains(QLatin1String(AUTODETECTED))
|| profile1.value(QLatin1String(AUTODETECTED)).toBool() != true)
return false;
return true;
}
