aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--autotests/kconfigtest.cpp627
-rw-r--r--autotests/kconfigtest.h4
2 files changed, 312 insertions, 319 deletions
diff --git a/autotests/kconfigtest.cpp b/autotests/kconfigtest.cpp
index e6d905b0..5cb31f49 100644
--- a/autotests/kconfigtest.cpp
+++ b/autotests/kconfigtest.cpp
@@ -4,9 +4,6 @@
SPDX-License-Identifier: LGPL-2.0-or-later
*/
-// Qt5 TODO: re-enable. No point in doing it before, it breaks on QString::fromUtf8(QByteArray), which exists in qt5.
-#undef QT_NO_CAST_FROM_BYTEARRAY
-
#include "kconfigtest.h"
#include "helper.h"
@@ -47,50 +44,46 @@ static QString homePath()
#endif
}
-#define BOOLENTRY1 true
-#define BOOLENTRY2 false
-#define STRINGENTRY1 "hello"
-#define STRINGENTRY2 " hello"
-#define STRINGENTRY3 "hello "
-#define STRINGENTRY4 " hello "
-#define STRINGENTRY5 " "
-#define STRINGENTRY6 ""
-#define UTF8BITENTRY "Hello äöü"
-#define TRANSLATEDSTRINGENTRY1 "bonjour"
-#define BYTEARRAYENTRY QByteArray( "\x00\xff\x7f\x3c abc\x00\x00", 10 )
-#define ESCAPEKEY " []\0017[]==]"
-#define ESCAPEENTRY "[]\170[]]=3=]\\] "
-#define DOUBLEENTRY 123456.78912345
-#define FLOATENTRY 123.567f
-#define POINTENTRY QPoint( 4351, 1235 )
-#define SIZEENTRY QSize( 10, 20 )
-#define RECTENTRY QRect( 10, 23, 5321, 13 )
-#define DATETIMEENTRY QDateTime( QDate( 2002, 06, 23 ), QTime( 12, 55, 40 ) )
-#define DATETIMEWITHMSENTRY QDateTime( QDate( 2002, 06, 23 ), QTime( 12, 55, 40, 532 ) )
-#define STRINGLISTENTRY (QStringList( "Hello," ) << " World")
-#define STRINGLISTEMPTYENTRY QStringList()
-#define STRINGLISTJUSTEMPTYELEMENT QStringList(QString())
-#define STRINGLISTEMPTYTRAINLINGELEMENT (QStringList( "Hi" ) << QString())
-#define STRINGLISTESCAPEODDENTRY (QStringList( "Hello\\\\\\" ) << "World")
-#define STRINGLISTESCAPEEVENENTRY (QStringList( "Hello\\\\\\\\" ) << "World")
-#define STRINGLISTESCAPECOMMAENTRY (QStringList( "Hel\\\\\\,\\\\,\\,\\\\\\\\,lo" ) << "World")
-#define INTLISTENTRY1 QList<int>() << 1 << 2 << 3 << 4
-#define BYTEARRAYLISTENTRY1 QList<QByteArray>() << "" << "1,2" << "end"
-#define VARIANTLISTENTRY (QVariantList() << true << false << QString("joe") << 10023)
-#define VARIANTLISTENTRY2 (QVariantList() << POINTENTRY << SIZEENTRY)
-#define HOMEPATH QString(homePath()+"/foo")
-#define HOMEPATHESCAPE QString(homePath()+"/foo/$HOME")
-#define DOLLARGROUP "$i"
-
-#define TEST_SUBDIR "kconfigtest_subdir/"
-
-static inline QString testConfigDir() {
- return QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/" TEST_SUBDIR;
-}
-
-static inline QString kdeGlobalsPath() {
- return QDir::cleanPath(testConfigDir() + "..") + "/kdeglobals";
-}
+const bool BOOLENTRY1 = true;
+const bool BOOLENTRY2 = false;
+
+// clazy:excludeall=non-pod-global-static
+
+const QString STRINGENTRY1(QStringLiteral("hello"));
+const QString STRINGENTRY2(QStringLiteral(" hello"));
+const QString STRINGENTRY3(QStringLiteral("hello "));
+const QString STRINGENTRY4(QStringLiteral(" hello "));
+const QString STRINGENTRY5(QStringLiteral(" "));
+const QString STRINGENTRY6{};
+
+const char UTF8BITENTRY[] = "Hello äöü";
+const QString TRANSLATEDSTRINGENTRY1{QStringLiteral("bonjour")};
+const QByteArray BYTEARRAYENTRY{"\x00\xff\x7f\x3c abc\x00\x00", 10};
+const char ESCAPEKEY[] = " []\0017[]==]";
+const char ESCAPEENTRY[] = "[]\170[]]=3=]\\] ";
+const double DOUBLEENTRY{123456.78912345};
+const float FLOATENTRY{123.567f};
+const QPoint POINTENTRY{4351, 1235};
+const QSize SIZEENTRY{10, 20};
+const QRect RECTENTRY{10, 23, 5321, 13};
+const QDateTime DATETIMEENTRY{QDate{2002, 06, 23}, QTime{12, 55, 40}};
+const QDateTime DATETIMEWITHMSENTRY{QDate{2002, 06, 23}, QTime{12, 55, 40, 532}};
+const QStringList STRINGLISTENTRY{QStringLiteral("Hello,"), QStringLiteral("World")};
+const QStringList STRINGLISTEMPTYENTRY{};
+const QStringList STRINGLISTJUSTEMPTYELEMENT{QString{}};
+const QStringList STRINGLISTEMPTYTRAILINGELEMENT{QStringLiteral("Hi"), QString{}};
+const QStringList STRINGLISTESCAPEODDENTRY{QStringLiteral("Hello\\\\\\"), QStringLiteral("World")};
+const QStringList STRINGLISTESCAPEEVENENTRY{QStringLiteral("Hello\\\\\\\\"), QStringLiteral("World")};
+const QStringList STRINGLISTESCAPECOMMAENTRY{QStringLiteral("Hel\\\\\\,\\\\,\\,\\\\\\\\,lo"), QStringLiteral("World")};
+const QList<int> INTLISTENTRY1{1, 2, 3, 4};
+const QList<QByteArray> BYTEARRAYLISTENTRY1{"", "1,2", "end"};
+const QVariantList VARIANTLISTENTRY{true, false, QStringLiteral("joe"), 10023};
+const QVariantList VARIANTLISTENTRY2{POINTENTRY, SIZEENTRY};
+
+const QString HOMEPATH{homePath() + QLatin1String{"/foo"}};
+const QString HOMEPATH_ESCAPE{homePath() + QLatin1String("/foo/$HOME")};
+const QString DOLLARGROUP{QStringLiteral("$i")};
+const QString TEST_SUBDIR{QStringLiteral("kconfigtest_subdir/")};
#ifndef Q_OS_WIN
void initLocale()
@@ -106,8 +99,13 @@ void KConfigTest::initTestCase()
{
// ensure we don't use files in the real config directory
QStandardPaths::setTestModeEnabled(true);
+
qRegisterMetaType<KConfigGroup>();
+ // These two need to be assigned here, after setTestModeEnabled(true), and before cleanupTestCase()
+ m_testConfigDir = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + QLatin1Char('/') + TEST_SUBDIR;
+ m_kdeGlobalsPath = QDir::cleanPath(m_testConfigDir + QLatin1String("..")) + QLatin1String("/kdeglobals");
+
// to make sure all files from a previous failed run are deleted
cleanupTestCase();
@@ -115,7 +113,7 @@ void KConfigTest::initTestCase()
mainConfig->group("Main").writeEntry("Key", "Value");
mainConfig->sync();
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup cg(&sc, "AAA");
cg.writeEntry("stringEntry1", STRINGENTRY1,
@@ -131,7 +129,7 @@ void KConfigTest::initTestCase()
QCOMPARE(QString::fromUtf8(data).length(), 9);
cg.writeEntry("Test", data);
cg.writeEntry("bytearrayEntry", BYTEARRAYENTRY);
- cg.writeEntry(ESCAPEKEY, ESCAPEENTRY);
+ cg.writeEntry(ESCAPEKEY, QStringLiteral(ESCAPEENTRY));
cg.writeEntry("emptyEntry", "");
cg.writeEntry("stringEntry1", STRINGENTRY1);
cg.writeEntry("stringEntry2", STRINGENTRY2);
@@ -142,8 +140,7 @@ void KConfigTest::initTestCase()
cg.writeEntry("keywith=equalsign", STRINGENTRY1);
cg.deleteEntry("stringEntry5");
cg.deleteEntry("stringEntry6"); // deleting a nonexistent entry
- cg.writeEntry("byteArrayEntry1", QByteArray(STRINGENTRY1),
- KConfig::Global | KConfig::Persistent);
+ cg.writeEntry("byteArrayEntry1", STRINGENTRY1.toLatin1(), KConfig::Global | KConfig::Persistent);
cg.writeEntry("doubleEntry1", DOUBLEENTRY);
cg.writeEntry("floatEntry1", FLOATENTRY);
@@ -176,7 +173,7 @@ void KConfigTest::initTestCase()
cg.writeEntry("stringListEntry", STRINGLISTENTRY);
cg.writeEntry("stringListEmptyEntry", STRINGLISTEMPTYENTRY);
cg.writeEntry("stringListJustEmptyElement", STRINGLISTJUSTEMPTYELEMENT);
- cg.writeEntry("stringListEmptyTrailingElement", STRINGLISTEMPTYTRAINLINGELEMENT);
+ cg.writeEntry("stringListEmptyTrailingElement", STRINGLISTEMPTYTRAILINGELEMENT);
cg.writeEntry("stringListEscapeOddEntry", STRINGLISTESCAPEODDENTRY);
cg.writeEntry("stringListEscapeEvenEntry", STRINGLISTESCAPEEVENENTRY);
cg.writeEntry("stringListEscapeCommaEntry", STRINGLISTESCAPECOMMAENTRY);
@@ -184,7 +181,7 @@ void KConfigTest::initTestCase()
cg = KConfigGroup(&sc, "Path Type");
cg.writePathEntry("homepath", HOMEPATH);
- cg.writePathEntry("homepathescape", HOMEPATHESCAPE);
+ cg.writePathEntry("homepathescape", HOMEPATH_ESCAPE);
cg = KConfigGroup(&sc, "Enum Types");
#if defined(_MSC_VER) && _MSC_VER == 1600
@@ -210,12 +207,10 @@ void KConfigTest::initTestCase()
QVERIFY(sc.sync());
QVERIFY(!sc.isDirty());
- QVERIFY2(QFile::exists(testConfigDir() + QStringLiteral("/kconfigtest")),
- qPrintable(testConfigDir() + QStringLiteral("/kconfigtest must exist")));
- QVERIFY2(QFile::exists(kdeGlobalsPath()),
- qPrintable(kdeGlobalsPath() + QStringLiteral(" must exist")));
+ QVERIFY2(QFile::exists(m_testConfigDir + QLatin1String("/kconfigtest")), qPrintable(m_testConfigDir + QLatin1String("/kconfigtest must exist")));
+ QVERIFY2(QFile::exists(m_kdeGlobalsPath), qPrintable(m_kdeGlobalsPath + QStringLiteral(" must exist")));
- KConfig sc1(TEST_SUBDIR "kdebugrc", KConfig::SimpleConfig);
+ KConfig sc1(TEST_SUBDIR + QLatin1String("kdebugrc"), KConfig::SimpleConfig);
KConfigGroup sg0(&sc1, "0");
sg0.writeEntry("AbortFatal", false);
sg0.writeEntry("WarnOutput", 0);
@@ -223,14 +218,14 @@ void KConfigTest::initTestCase()
QVERIFY(sc1.sync());
//Setup stuff to test KConfig::addConfigSources()
- KConfig devcfg(TEST_SUBDIR "specificrc");
+ KConfig devcfg(TEST_SUBDIR + QLatin1String("specificrc"));
KConfigGroup devonlygrp(&devcfg, "Specific Only Group");
devonlygrp.writeEntry("ExistingEntry", "DevValue");
KConfigGroup devandbasegrp(&devcfg, "Shared Group");
devandbasegrp.writeEntry("SomeSharedEntry", "DevValue");
devandbasegrp.writeEntry("SomeSpecificOnlyEntry", "DevValue");
QVERIFY(devcfg.sync());
- KConfig basecfg(TEST_SUBDIR "baserc");
+ KConfig basecfg(TEST_SUBDIR + QLatin1String("baserc"));
KConfigGroup basegrp(&basecfg, "Base Only Group");
basegrp.writeEntry("ExistingEntry", "BaseValue");
KConfigGroup baseanddevgrp(&basecfg, "Shared Group");
@@ -238,7 +233,7 @@ void KConfigTest::initTestCase()
baseanddevgrp.writeEntry("SomeBaseOnlyEntry", "BaseValue");
QVERIFY(basecfg.sync());
- KConfig gecfg(TEST_SUBDIR "groupescapetest", KConfig::SimpleConfig);
+ KConfig gecfg(TEST_SUBDIR + QLatin1String("groupescapetest"), KConfig::SimpleConfig);
cg = KConfigGroup(&gecfg, DOLLARGROUP);
cg.writeEntry("entry", "doesntmatter");
@@ -247,16 +242,15 @@ void KConfigTest::initTestCase()
void KConfigTest::cleanupTestCase()
{
//ensure we don't delete the real directory
- QDir localConfig(testConfigDir());
+ QDir localConfig(m_testConfigDir);
//qDebug() << "Erasing" << localConfig;
if (localConfig.exists()) {
QVERIFY(localConfig.removeRecursively());
}
QVERIFY(!localConfig.exists());
- if (QFile::exists(kdeGlobalsPath())) {
- QVERIFY(QFile::remove(kdeGlobalsPath()));
+ if (QFile::exists(m_kdeGlobalsPath)) {
+ QVERIFY(QFile::remove(m_kdeGlobalsPath));
}
-
}
static QList<QByteArray> readLinesFrom(const QString &path)
@@ -278,17 +272,18 @@ static QList<QByteArray> readLinesFrom(const QString &path)
return lines;
}
-static QList<QByteArray> readLines(const char *fileName = TEST_SUBDIR "kconfigtest")
+static const QString s_defaultArg = TEST_SUBDIR + QLatin1String("kconfigtest");
+static QList<QByteArray> readLines(const QString &fileName = s_defaultArg)
{
const QString path = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
Q_ASSERT(!path.isEmpty());
- return readLinesFrom(path + '/' + fileName);
+ return readLinesFrom(path + QLatin1Char('/') + fileName);
}
// see also testDefaults, which tests reverting with a defaults (global) file available
void KConfigTest::testDirtyAfterRevert()
{
- KConfig sc(TEST_SUBDIR "kconfigtest_revert");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest_revert"));
KConfigGroup cg(&sc, "Hello");
cg.revertToDefault("does_not_exist");
@@ -312,21 +307,21 @@ void KConfigTest::testRevertAllEntries()
// this tests the case were we revert (delete) all entries in a file,
// leaving a blank file
{
- KConfig sc(TEST_SUBDIR "konfigtest2", KConfig::SimpleConfig);
+ KConfig sc(TEST_SUBDIR + QLatin1String("konfigtest2"), KConfig::SimpleConfig);
KConfigGroup cg(&sc, "Hello");
cg.writeEntry("Test", "Correct");
}
{
- KConfig sc(TEST_SUBDIR "konfigtest2", KConfig::SimpleConfig);
+ KConfig sc(TEST_SUBDIR + QLatin1String("konfigtest2"), KConfig::SimpleConfig);
KConfigGroup cg(&sc, "Hello");
- QCOMPARE(cg.readEntry("Test", "Default"), QString("Correct"));
+ QCOMPARE(cg.readEntry("Test", "Default"), QStringLiteral("Correct"));
cg.revertToDefault("Test");
}
- KConfig sc(TEST_SUBDIR "konfigtest2", KConfig::SimpleConfig);
+ KConfig sc(TEST_SUBDIR + QLatin1String("konfigtest2"), KConfig::SimpleConfig);
KConfigGroup cg(&sc, "Hello");
- QCOMPARE(cg.readEntry("Test", "Default"), QString("Default"));
+ QCOMPARE(cg.readEntry("Test", "Default"), QStringLiteral("Default"));
}
void KConfigTest::testSimple()
@@ -335,13 +330,13 @@ void KConfigTest::testSimple()
const QStringList kdeglobals = QStandardPaths::locateAll(QStandardPaths::GenericConfigLocation, QStringLiteral("kdeglobals"));
QVERIFY(!kdeglobals.isEmpty());
- KConfig sc2(TEST_SUBDIR "kconfigtest");
- QCOMPARE(sc2.name(), QString(TEST_SUBDIR "kconfigtest"));
+ KConfig sc2(TEST_SUBDIR + QLatin1String{"kconfigtest"});
+ QCOMPARE(sc2.name(), TEST_SUBDIR + QLatin1String{"kconfigtest"});
// make sure groupList() isn't returning something it shouldn't
const QStringList lstGroup = sc2.groupList();
for (const QString &group : lstGroup) {
- QVERIFY(!group.isEmpty() && group != "<default>");
+ QVERIFY(!group.isEmpty() && group != QLatin1String("<default>"));
QVERIFY(!group.contains(QChar(0x1d)));
}
@@ -349,43 +344,43 @@ void KConfigTest::testSimple()
QVERIFY(sc3.hasKey("stringEntry1")); // from kdeglobals
QVERIFY(!sc3.isEntryImmutable("stringEntry1"));
- QCOMPARE(sc3.readEntry("stringEntry1"), QString(STRINGENTRY1));
+ QCOMPARE(sc3.readEntry("stringEntry1"), STRINGENTRY1);
QVERIFY(!sc3.hasKey("stringEntry2"));
- QCOMPARE(sc3.readEntry("stringEntry2", QString("bla")), QString("bla"));
+ QCOMPARE(sc3.readEntry("stringEntry2", QStringLiteral("bla")), QStringLiteral("bla"));
QVERIFY(!sc3.hasDefault("stringEntry1"));
sc3 = KConfigGroup(&sc2, "Hello");
QCOMPARE(sc3.readEntry("Test", QByteArray()), QByteArray(UTF8BITENTRY));
QCOMPARE(sc3.readEntry("bytearrayEntry", QByteArray()), BYTEARRAYENTRY);
- QCOMPARE(sc3.readEntry(ESCAPEKEY), QString(ESCAPEENTRY));
- QCOMPARE(sc3.readEntry("Test", QString()), QString::fromUtf8(UTF8BITENTRY));
+ QCOMPARE(sc3.readEntry(ESCAPEKEY), QString::fromLatin1(ESCAPEENTRY));
+ QCOMPARE(sc3.readEntry("Test", QString{}), QString::fromUtf8(UTF8BITENTRY));
QCOMPARE(sc3.readEntry("emptyEntry"/*, QString("Fietsbel")*/), QLatin1String(""));
- QCOMPARE(sc3.readEntry("emptyEntry", QString("Fietsbel")).isEmpty(), true);
- QCOMPARE(sc3.readEntry("stringEntry1"), QString(STRINGENTRY1));
- QCOMPARE(sc3.readEntry("stringEntry2"), QString(STRINGENTRY2));
- QCOMPARE(sc3.readEntry("stringEntry3"), QString(STRINGENTRY3));
- QCOMPARE(sc3.readEntry("stringEntry4"), QString(STRINGENTRY4));
+ QCOMPARE(sc3.readEntry("emptyEntry", QStringLiteral("Fietsbel")).isEmpty(), true);
+ QCOMPARE(sc3.readEntry("stringEntry1"), STRINGENTRY1);
+ QCOMPARE(sc3.readEntry("stringEntry2"), STRINGENTRY2);
+ QCOMPARE(sc3.readEntry("stringEntry3"), STRINGENTRY3);
+ QCOMPARE(sc3.readEntry("stringEntry4"), STRINGENTRY4);
QVERIFY(!sc3.hasKey("stringEntry5"));
- QCOMPARE(sc3.readEntry("stringEntry5", QString("test")), QString("test"));
+ QCOMPARE(sc3.readEntry("stringEntry5", QStringLiteral("test")), QStringLiteral("test"));
QVERIFY(!sc3.hasKey("stringEntry6"));
- QCOMPARE(sc3.readEntry("stringEntry6", QString("foo")), QString("foo"));
- QCOMPARE(sc3.readEntry("urlEntry1", QUrl()), QUrl("http://qt-project.org"));
+ QCOMPARE(sc3.readEntry("stringEntry6", QStringLiteral("foo")), QStringLiteral("foo"));
+ QCOMPARE(sc3.readEntry("urlEntry1", QUrl{}), QUrl(QStringLiteral("http://qt-project.org")));
QCOMPARE(sc3.readEntry("boolEntry1", BOOLENTRY1), BOOLENTRY1);
QCOMPARE(sc3.readEntry("boolEntry2", false), BOOLENTRY2);
- QCOMPARE(sc3.readEntry("keywith=equalsign", QString("wrong")), QString(STRINGENTRY1));
- QCOMPARE(sc3.readEntry("byteArrayEntry1", QByteArray()),
- QByteArray(STRINGENTRY1));
+ QCOMPARE(sc3.readEntry("keywith=equalsign", QStringLiteral("wrong")), STRINGENTRY1);
+ QCOMPARE(sc3.readEntry("byteArrayEntry1", QByteArray{}), STRINGENTRY1.toLatin1());
QCOMPARE(sc3.readEntry("doubleEntry1", 0.0), DOUBLEENTRY);
QCOMPARE(sc3.readEntry("floatEntry1", 0.0f), FLOATENTRY);
}
void KConfigTest::testDefaults()
{
- KConfig config(TEST_SUBDIR "defaulttest", KConfig::NoGlobals);
- const QString defaultsFile = TEST_SUBDIR "defaulttest.defaults";
+ KConfig config(TEST_SUBDIR + QLatin1String("defaulttest"), KConfig::NoGlobals);
+ const QString defaultsFile = TEST_SUBDIR + QLatin1String("defaulttest.defaults");
KConfig defaults(defaultsFile, KConfig::SimpleConfig);
+ const QString defaultsFilePath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + QLatin1Char('/') + defaultsFile;
const QString Default(QStringLiteral("Default"));
const QString NotDefault(QStringLiteral("Not Default"));
@@ -401,7 +396,7 @@ void KConfigTest::testDefaults()
group.writeEntry("entry2", Value2);
QVERIFY(group.sync());
- config.addConfigSources(QStringList() << QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + '/' + defaultsFile);
+ config.addConfigSources(QStringList{defaultsFilePath});
config.setReadDefaults(true);
QCOMPARE(group.readEntry("entry1", QString()), Default);
@@ -422,8 +417,8 @@ void KConfigTest::testDefaults()
group.sync();
// Check that everything is OK on disk, too
- KConfig reader(TEST_SUBDIR "defaulttest", KConfig::NoGlobals);
- reader.addConfigSources(QStringList() << QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + '/' + defaultsFile);
+ KConfig reader(TEST_SUBDIR + QLatin1String("defaulttest"), KConfig::NoGlobals);
+ reader.addConfigSources(QStringList{defaultsFilePath});
KConfigGroup readerGroup = reader.group("any group");
QCOMPARE(readerGroup.readEntry("entry1", QString()), Default);
QCOMPARE(readerGroup.readEntry("entry2", QString()), QString());
@@ -431,7 +426,7 @@ void KConfigTest::testDefaults()
void KConfigTest::testLocale()
{
- KConfig config(TEST_SUBDIR "kconfigtest.locales", KConfig::SimpleConfig);
+ KConfig config(TEST_SUBDIR + QLatin1String("kconfigtest.locales"), KConfig::SimpleConfig);
const QString Translated(TRANSLATEDSTRINGENTRY1);
const QString Untranslated(STRINGENTRY1);
@@ -453,71 +448,69 @@ void KConfigTest::testLocale()
void KConfigTest::testEncoding()
{
- QString groupstr = QString::fromUtf8("UTF-8:\xc3\xb6l");
+ const QString groupstr = QString::fromUtf8("UTF-8:\xc3\xb6l");
- KConfig c(TEST_SUBDIR "kconfigtestencodings");
+ const QString path = TEST_SUBDIR + QLatin1String("kconfigtestencodings");
+ KConfig c(path);
KConfigGroup cg(&c, groupstr);
cg.writeEntry("key", "value");
QVERIFY(c.sync());
- QList<QByteArray> lines = readLines(TEST_SUBDIR "kconfigtestencodings");
+ const QList<QByteArray> lines = readLines(path);
QCOMPARE(lines.count(), 2);
QCOMPARE(lines.first(), QByteArray("[UTF-8:\xc3\xb6l]\n"));
- KConfig c2(TEST_SUBDIR "kconfigtestencodings");
+ KConfig c2(path);
KConfigGroup cg2(&c2, groupstr);
- QVERIFY(cg2.readEntry("key") == QByteArray("value"));
+ QCOMPARE(cg2.readEntry("key"), QStringLiteral("value"));
QVERIFY(c2.groupList().contains(groupstr));
}
void KConfigTest::testLists()
{
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup sc3(&sc2, "List Types");
- QCOMPARE(sc3.readEntry(QString("stringListEntry"), QStringList()),
- STRINGLISTENTRY);
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListEntry"), QStringList()), STRINGLISTENTRY);
- QCOMPARE(sc3.readEntry(QString("stringListEmptyEntry"), QStringList("wrong")),
- STRINGLISTEMPTYENTRY);
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListEmptyEntry"), QStringList(QStringLiteral("wrong"))), STRINGLISTEMPTYENTRY);
- QCOMPARE(sc3.readEntry(QString("stringListJustEmptyElement"), QStringList()),
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListJustEmptyElement"), QStringList()),
STRINGLISTJUSTEMPTYELEMENT);
- QCOMPARE(sc3.readEntry(QString("stringListEmptyTrailingElement"), QStringList()),
- STRINGLISTEMPTYTRAINLINGELEMENT);
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListEmptyTrailingElement"), QStringList()),
+ STRINGLISTEMPTYTRAILINGELEMENT);
- QCOMPARE(sc3.readEntry(QString("stringListEscapeOddEntry"), QStringList()),
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListEscapeOddEntry"), QStringList()),
STRINGLISTESCAPEODDENTRY);
- QCOMPARE(sc3.readEntry(QString("stringListEscapeEvenEntry"), QStringList()),
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListEscapeEvenEntry"), QStringList()),
STRINGLISTESCAPEEVENENTRY);
- QCOMPARE(sc3.readEntry(QString("stringListEscapeCommaEntry"), QStringList()),
+ QCOMPARE(sc3.readEntry(QStringLiteral("stringListEscapeCommaEntry"), QStringList()),
STRINGLISTESCAPECOMMAENTRY);
QCOMPARE(sc3.readEntry("listOfIntsEntry1"), QString::fromLatin1("1,2,3,4"));
QList<int> expectedIntList = INTLISTENTRY1;
QVERIFY(sc3.readEntry("listOfIntsEntry1", QList<int>()) == expectedIntList);
- QCOMPARE(QVariant(sc3.readEntry("variantListEntry", VARIANTLISTENTRY)).toStringList(),
- QVariant(VARIANTLISTENTRY).toStringList());
+ QCOMPARE(QVariant(sc3.readEntry("variantListEntry", VARIANTLISTENTRY)).toStringList(), QVariant(VARIANTLISTENTRY).toStringList());
QCOMPARE(sc3.readEntry("listOfByteArraysEntry1", QList<QByteArray>()), BYTEARRAYLISTENTRY1);
}
void KConfigTest::testPath()
{
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup sc3(&sc2, "Path Type");
- QCOMPARE(sc3.readPathEntry("homepath", QString()), HOMEPATH);
- QCOMPARE(sc3.readPathEntry("homepathescape", QString()), HOMEPATHESCAPE);
- QCOMPARE(sc3.entryMap().value("homepath"), HOMEPATH);
+ QCOMPARE(sc3.readPathEntry(QStringLiteral("homepath"), QString{}), HOMEPATH);
+ QCOMPARE(sc3.readPathEntry(QStringLiteral("homepathescape"), QString{}), HOMEPATH_ESCAPE);
+ QCOMPARE(sc3.entryMap().value(QStringLiteral("homepath")), HOMEPATH);
qputenv("WITHSLASH", "/a/");
{
- QFile file(testConfigDir() + "/pathtest");
+ QFile file(m_testConfigDir + QLatin1String("/pathtest"));
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -535,27 +528,27 @@ void KConfigTest::testPath()
<< "noeol=foo" // no EOL
;
}
- KConfig cf2(TEST_SUBDIR "pathtest");
+ KConfig cf2(TEST_SUBDIR + QLatin1String("pathtest"));
KConfigGroup group = cf2.group("Test Group");
QVERIFY(group.hasKey("homePath"));
- QCOMPARE(group.readPathEntry("homePath", QString()), HOMEPATH);
+ QCOMPARE(group.readPathEntry("homePath", QString{}), HOMEPATH);
QVERIFY(group.hasKey("homePath2"));
- QCOMPARE(group.readPathEntry("homePath2", QString()), QString("file://" + HOMEPATH));
+ QCOMPARE(group.readPathEntry("homePath2", QString{}), QLatin1String("file://") + HOMEPATH);
QVERIFY(group.hasKey("withSlash"));
- QCOMPARE(group.readPathEntry("withSlash", QString()), QStringLiteral("/a//foo"));
+ QCOMPARE(group.readPathEntry("withSlash", QString{}), QStringLiteral("/a//foo"));
QVERIFY(group.hasKey("withSlash2"));
- QCOMPARE(group.readPathEntry("withSlash2", QString()), QStringLiteral("/a/"));
+ QCOMPARE(group.readPathEntry("withSlash2", QString{}), QStringLiteral("/a/"));
QVERIFY(group.hasKey("withBraces"));
- QCOMPARE(group.readPathEntry("withBraces", QString()), QString("file://" + HOMEPATH));
+ QCOMPARE(group.readPathEntry("withBraces", QString{}), QLatin1String("file://") + HOMEPATH);
QVERIFY(group.hasKey("URL"));
- QCOMPARE(group.readEntry("URL", QString()), QString("file://" + HOMEPATH));
+ QCOMPARE(group.readEntry("URL", QString{}), QLatin1String("file://") + HOMEPATH);
QVERIFY(group.hasKey("hostname"));
- QCOMPARE(group.readEntry("hostname", QString()), QStringLiteral("(hostname)")); // the $ got removed because empty var name
+ QCOMPARE(group.readEntry("hostname", QString{}), QStringLiteral("(hostname)")); // the $ got removed because empty var name
QVERIFY(group.hasKey("noeol"));
- QCOMPARE(group.readEntry("noeol", QString()), QString("foo"));
+ QCOMPARE(group.readEntry("noeol", QString{}), QStringLiteral("foo"));
const auto val = QStringList { QStringLiteral("aaa"), QStringLiteral("bb/b"), QStringLiteral("ccc,ccc")};
- QCOMPARE(group.readPathEntry("escapes", QStringList()), val);
+ QCOMPARE(group.readPathEntry(QStringLiteral("escapes"), QStringList()), val);
}
void KConfigTest::testPersistenceOfExpandFlagForPath()
@@ -567,7 +560,7 @@ void KConfigTest::testPersistenceOfExpandFlagForPath()
// 1st step: Open the config, add a new dummy entry and then sync the config
// back to the storage.
{
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup sc3(&sc2, "Path Type");
sc3.writeEntry("dummy", "dummy");
QVERIFY(sc2.sync());
@@ -581,7 +574,7 @@ void KConfigTest::testPersistenceOfExpandFlagForPath()
void KConfigTest::testPathQtHome()
{
{
- QFile file(testConfigDir() + "/pathtest");
+ QFile file(m_testConfigDir + QLatin1String("/pathtest"));
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -592,42 +585,39 @@ void KConfigTest::testPathQtHome()
<< "cacheDir[$e]=$QT_CACHE_HOME/kconfigtest\n"
<< "configDir[$e]=$QT_CONFIG_HOME/kconfigtest\n";
}
- KConfig cf2(TEST_SUBDIR "pathtest");
+ KConfig cf2(TEST_SUBDIR + QLatin1String("pathtest"));
KConfigGroup group = cf2.group("Test Group");
qunsetenv("QT_DATA_HOME");
qunsetenv("QT_CACHE_HOME");
qunsetenv("QT_CONFIG_HOME");
QVERIFY(group.hasKey("dataDir"));
- QCOMPARE(group.readEntry("dataDir", QString()), QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation).append(QStringLiteral("/kconfigtest")));
+ QCOMPARE(group.readEntry("dataDir", QString{}), QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation).append(QStringLiteral("/kconfigtest")));
QVERIFY(group.hasKey("cacheDir"));
- QCOMPARE(group.readEntry("cacheDir", QString()), QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation).append(QStringLiteral("/kconfigtest")));
+ QCOMPARE(group.readEntry("cacheDir", QString{}), QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation).append(QStringLiteral("/kconfigtest")));
QVERIFY(group.hasKey("configDir"));
- QCOMPARE(group.readEntry("configDir", QString()), QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation).append(QStringLiteral("/kconfigtest")));
+ QCOMPARE(group.readEntry("configDir", QString{}), QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation).append(QStringLiteral("/kconfigtest")));
qputenv("QT_DATA_HOME","/1");
qputenv("QT_CACHE_HOME","/2");
qputenv("QT_CONFIG_HOME","/3");
QVERIFY(group.hasKey("dataDir"));
- QCOMPARE(group.readEntry("dataDir", QString()), QStringLiteral("/1/kconfigtest"));
+ QCOMPARE(group.readEntry("dataDir", QString{}), QStringLiteral("/1/kconfigtest"));
QVERIFY(group.hasKey("cacheDir"));
- QCOMPARE(group.readEntry("cacheDir", QString()), QStringLiteral("/2/kconfigtest"));
+ QCOMPARE(group.readEntry("cacheDir", QString{}), QStringLiteral("/2/kconfigtest"));
QVERIFY(group.hasKey("configDir"));
- QCOMPARE(group.readEntry("configDir", QString()), QStringLiteral("/3/kconfigtest"));
+ QCOMPARE(group.readEntry("configDir", QString{}), QStringLiteral("/3/kconfigtest"));
}
void KConfigTest::testComplex()
{
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup sc3(&sc2, "Complex Types");
QCOMPARE(sc3.readEntry("pointEntry", QPoint()), POINTENTRY);
QCOMPARE(sc3.readEntry("sizeEntry", SIZEENTRY), SIZEENTRY);
QCOMPARE(sc3.readEntry("rectEntry", QRect(1, 2, 3, 4)), RECTENTRY);
- QCOMPARE(sc3.readEntry("dateTimeEntry", QDateTime()).toString(Qt::ISODateWithMs),
- DATETIMEENTRY.toString(Qt::ISODateWithMs));
- QCOMPARE(sc3.readEntry("dateEntry", QDate()).toString(Qt::ISODate),
- DATETIMEENTRY.date().toString(Qt::ISODate));
- QCOMPARE(sc3.readEntry("dateTimeWithMSEntry", QDateTime()).toString(Qt::ISODateWithMs),
- DATETIMEWITHMSENTRY.toString(Qt::ISODateWithMs));
+ QCOMPARE(sc3.readEntry("dateTimeEntry", QDateTime()).toString(Qt::ISODateWithMs), DATETIMEENTRY.toString(Qt::ISODateWithMs));
+ QCOMPARE(sc3.readEntry("dateEntry", QDate()).toString(Qt::ISODate), DATETIMEENTRY.date().toString(Qt::ISODate));
+ QCOMPARE(sc3.readEntry("dateTimeWithMSEntry", QDateTime()).toString(Qt::ISODateWithMs), DATETIMEWITHMSENTRY.toString(Qt::ISODateWithMs));
QCOMPARE(sc3.readEntry("dateTimeEntry", QDate()), DATETIMEENTRY.date());
}
@@ -639,14 +629,14 @@ void KConfigTest::testEnums()
#if defined(_MSC_VER) && _MSC_VER == 1600
QSKIP("Visual C++ 2010 can't compile this test");
#endif
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup sc3(&sc, "Enum Types");
- QCOMPARE(sc3.readEntry("enum-10"), QString("Tens"));
+ QCOMPARE(sc3.readEntry("enum-10"), QStringLiteral("Tens"));
QVERIFY(sc3.readEntry("enum-100", Ones) != Ones);
QVERIFY(sc3.readEntry("enum-100", Ones) != Tens);
- QCOMPARE(sc3.readEntry("flags-bit0"), QString("bit0"));
+ QCOMPARE(sc3.readEntry("flags-bit0"), QStringLiteral("bit0"));
QVERIFY(sc3.readEntry("flags-bit0", Flags()) == bit0);
int eid = staticMetaObject.indexOfEnumerator("Flags");
@@ -654,37 +644,37 @@ void KConfigTest::testEnums()
QMetaEnum me = staticMetaObject.enumerator(eid);
Flags bitfield = bit0 | bit1;
- QCOMPARE(sc3.readEntry("flags-bit0-bit1"), QString(me.valueToKeys(bitfield)));
+ QCOMPARE(sc3.readEntry("flags-bit0-bit1"), QString::fromLatin1(me.valueToKeys(bitfield)));
QVERIFY(sc3.readEntry("flags-bit0-bit1", Flags()) == bitfield);
}
void KConfigTest::testEntryMap()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup cg(&sc, "Hello");
QMap<QString, QString> entryMap = cg.entryMap();
qDebug() << entryMap.keys();
- QCOMPARE(entryMap.value("stringEntry1"), QString(STRINGENTRY1));
- QCOMPARE(entryMap.value("stringEntry2"), QString(STRINGENTRY2));
- QCOMPARE(entryMap.value("stringEntry3"), QString(STRINGENTRY3));
- QCOMPARE(entryMap.value("stringEntry4"), QString(STRINGENTRY4));
- QVERIFY(!entryMap.contains("stringEntry5"));
- QVERIFY(!entryMap.contains("stringEntry6"));
- QCOMPARE(entryMap.value("Test"), QString::fromUtf8(UTF8BITENTRY));
- QCOMPARE(entryMap.value("bytearrayEntry"), QString::fromUtf8(BYTEARRAYENTRY.constData()));
- QCOMPARE(entryMap.value("emptyEntry"), QString());
- QVERIFY(entryMap.contains("emptyEntry"));
- QCOMPARE(entryMap.value("boolEntry1"), QString(BOOLENTRY1 ? "true" : "false"));
- QCOMPARE(entryMap.value("boolEntry2"), QString(BOOLENTRY2 ? "true" : "false"));
- QCOMPARE(entryMap.value("keywith=equalsign"), QString(STRINGENTRY1));
- QCOMPARE(entryMap.value("byteArrayEntry1"), QString(STRINGENTRY1));
- QCOMPARE(entryMap.value("doubleEntry1").toDouble(), DOUBLEENTRY);
- QCOMPARE(entryMap.value("floatEntry1").toFloat(), FLOATENTRY);
+ QCOMPARE(entryMap.value(QStringLiteral("stringEntry1")), STRINGENTRY1);
+ QCOMPARE(entryMap.value(QStringLiteral("stringEntry2")), STRINGENTRY2);
+ QCOMPARE(entryMap.value(QStringLiteral("stringEntry3")), STRINGENTRY3);
+ QCOMPARE(entryMap.value(QStringLiteral("stringEntry4")), STRINGENTRY4);
+ QVERIFY(!entryMap.contains(QStringLiteral("stringEntry5")));
+ QVERIFY(!entryMap.contains(QStringLiteral("stringEntry6")));
+ QCOMPARE(entryMap.value(QStringLiteral("Test")), QString::fromUtf8(UTF8BITENTRY));
+ QCOMPARE(entryMap.value(QStringLiteral("bytearrayEntry")), QString::fromUtf8(BYTEARRAYENTRY.constData()));
+ QCOMPARE(entryMap.value(QStringLiteral("emptyEntry")), QString{});
+ QVERIFY(entryMap.contains(QStringLiteral("emptyEntry")));
+ QCOMPARE(entryMap.value(QStringLiteral("boolEntry1")), BOOLENTRY1 ? QStringLiteral("true") : QStringLiteral("false"));
+ QCOMPARE(entryMap.value(QStringLiteral("boolEntry2")), BOOLENTRY2 ? QStringLiteral("true") : QStringLiteral("false"));
+ QCOMPARE(entryMap.value(QStringLiteral("keywith=equalsign")), STRINGENTRY1);
+ QCOMPARE(entryMap.value(QStringLiteral("byteArrayEntry1")), STRINGENTRY1);
+ QCOMPARE(entryMap.value(QStringLiteral("doubleEntry1")).toDouble(), DOUBLEENTRY);
+ QCOMPARE(entryMap.value(QStringLiteral("floatEntry1")).toFloat(), FLOATENTRY);
}
void KConfigTest::testInvalid()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
// all of these should print a message to the kdebug.dbg file
KConfigGroup sc3(&sc, "Invalid Types");
@@ -751,37 +741,38 @@ void KConfigTest::testInvalid()
void KConfigTest::testChangeGroup()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup sc3(&sc, "Hello");
- QCOMPARE(sc3.name(), QString("Hello"));
+ QCOMPARE(sc3.name(), QStringLiteral("Hello"));
KConfigGroup newGroup(sc3);
#if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
newGroup.changeGroup("FooBar"); // deprecated!
- QCOMPARE(newGroup.name(), QString("FooBar"));
- QCOMPARE(sc3.name(), QString("Hello")); // unchanged
+ QCOMPARE(newGroup.name(), QStringLiteral("FooBar"));
+ QCOMPARE(sc3.name(), QStringLiteral("Hello")); // unchanged
// Write into the "changed group" and check that it works
newGroup.writeEntry("InFooBar", "FB");
- QCOMPARE(KConfigGroup(&sc, "FooBar").entryMap().value("InFooBar"), QString("FB"));
- QCOMPARE(KConfigGroup(&sc, "Hello").entryMap().value("InFooBar"), QString());
+ QCOMPARE(KConfigGroup(&sc, "FooBar").entryMap().value(QStringLiteral("InFooBar")), QStringLiteral("FB"));
+ QCOMPARE(KConfigGroup(&sc, "Hello").entryMap().value(QStringLiteral("InFooBar")), QString{});
#endif
KConfigGroup rootGroup(sc.group(""));
- QCOMPARE(rootGroup.name(), QString("<default>"));
+ QCOMPARE(rootGroup.name(), QStringLiteral("<default>"));
KConfigGroup sc32(rootGroup.group("Hello"));
- QCOMPARE(sc32.name(), QString("Hello"));
+ QCOMPARE(sc32.name(), QStringLiteral("Hello"));
KConfigGroup newGroup2(sc32);
#if KCONFIGCORE_ENABLE_DEPRECATED_SINCE(5, 0)
newGroup2.changeGroup("FooBar"); // deprecated!
- QCOMPARE(newGroup2.name(), QString("FooBar"));
- QCOMPARE(sc32.name(), QString("Hello")); // unchanged
+ QCOMPARE(newGroup2.name(), QStringLiteral("FooBar"));
+ QCOMPARE(sc32.name(), QStringLiteral("Hello")); // unchanged
#endif
}
// Simple test for deleteEntry
void KConfigTest::testDeleteEntry()
{
- const char *configFile = TEST_SUBDIR "kconfigdeletetest";
+ const QString configFile = TEST_SUBDIR + QLatin1String("kconfigdeletetest");
+
{
KConfig conf(configFile);
conf.group("Hello").writeEntry("DelKey", "ToBeDeleted");
@@ -794,16 +785,16 @@ void KConfigTest::testDeleteEntry()
KConfigGroup group(&sc, "Hello");
group.deleteEntry("DelKey");
- QCOMPARE(group.readEntry("DelKey", QString("Fietsbel")), QString("Fietsbel"));
+ QCOMPARE(group.readEntry("DelKey", QStringLiteral("Fietsbel")), QStringLiteral("Fietsbel"));
QVERIFY(group.sync());
Q_ASSERT(!readLines(configFile).contains("DelKey=ToBeDeleted\n"));
- QCOMPARE(group.readEntry("DelKey", QString("still deleted")), QString("still deleted"));
+ QCOMPARE(group.readEntry("DelKey", QStringLiteral("still deleted")), QStringLiteral("still deleted"));
}
void KConfigTest::testDelete()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup ct(&sc, "Complex Types");
@@ -814,7 +805,7 @@ void KConfigTest::testDelete()
delgr.deleteGroup();
QVERIFY(!delgr.exists());
QVERIFY(!ct.hasGroup("Nested Group 3"));
- QVERIFY(ct.groupList().contains("Nested Group 3"));
+ QVERIFY(ct.groupList().contains(QStringLiteral("Nested Group 3")));
KConfigGroup ng(&ct, "Nested Group 2");
QVERIFY(sc.hasGroup("Complex Types"));
@@ -831,10 +822,10 @@ void KConfigTest::testDelete()
KConfigGroup cg(&sc, "AAA");
cg.deleteGroup();
- QVERIFY(sc.entryMap("Complex Types").isEmpty());
- QVERIFY(sc.entryMap("AAA").isEmpty());
- QVERIFY(!sc.entryMap("Hello").isEmpty()); //not deleted group
- QVERIFY(sc.entryMap("FooBar").isEmpty()); //inexistant group
+ QVERIFY(sc.entryMap(QStringLiteral("Complex Types")).isEmpty());
+ QVERIFY(sc.entryMap(QStringLiteral("AAA")).isEmpty());
+ QVERIFY(!sc.entryMap(QStringLiteral("Hello")).isEmpty()); //not deleted group
+ QVERIFY(sc.entryMap(QStringLiteral("FooBar")).isEmpty()); //inexistant group
QVERIFY(cg.sync());
// Check what happens on disk
@@ -848,7 +839,7 @@ void KConfigTest::testDelete()
QVERIFY(lines.contains("[Hello]\n")); // a group that was not deleted
// test for entries that are marked as deleted when there is no default
- KConfig cf(TEST_SUBDIR "kconfigtest", KConfig::SimpleConfig); // make sure there are no defaults
+ KConfig cf(TEST_SUBDIR + QLatin1String("kconfigtest"), KConfig::SimpleConfig); // make sure there are no defaults
cg = cf.group("Portable Devices");
cg.writeEntry("devices|manual|(null)", "whatever");
cg.writeEntry("devices|manual|/mnt/ipod", "/mnt/ipod");
@@ -871,40 +862,41 @@ void KConfigTest::testDelete()
void KConfigTest::testDefaultGroup()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup defaultGroup(&sc, "<default>");
- QCOMPARE(defaultGroup.name(), QString("<default>"));
+ QCOMPARE(defaultGroup.name(), QStringLiteral("<default>"));
QVERIFY(!defaultGroup.exists());
defaultGroup.writeEntry("TestKey", "defaultGroup");
QVERIFY(defaultGroup.exists());
- QCOMPARE(defaultGroup.readEntry("TestKey", QString()), QString("defaultGroup"));
+ QCOMPARE(defaultGroup.readEntry("TestKey", QString{}), QStringLiteral("defaultGroup"));
QVERIFY(sc.sync());
{
// Test reading it
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup defaultGroup2(&sc2, "<default>");
- QCOMPARE(defaultGroup2.name(), QString("<default>"));
+ QCOMPARE(defaultGroup2.name(), QStringLiteral("<default>"));
QVERIFY(defaultGroup2.exists());
- QCOMPARE(defaultGroup2.readEntry("TestKey", QString()), QString("defaultGroup"));
+ QCOMPARE(defaultGroup2.readEntry("TestKey", QString{}), QStringLiteral("defaultGroup"));
}
{
// Test reading it
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup emptyGroup(&sc2, "");
- QCOMPARE(emptyGroup.name(), QString("<default>"));
+ QCOMPARE(emptyGroup.name(), QStringLiteral("<default>"));
QVERIFY(emptyGroup.exists());
- QCOMPARE(emptyGroup.readEntry("TestKey", QString()), QString("defaultGroup"));
+ QCOMPARE(emptyGroup.readEntry("TestKey", QString{}), QStringLiteral("defaultGroup"));
}
QList<QByteArray> lines = readLines();
QVERIFY(!lines.contains("[]\n"));
+ QVERIFY(!lines.isEmpty());
QCOMPARE(lines.first(), QByteArray("TestKey=defaultGroup\n"));
// Now that the group exists make sure it isn't returned from groupList()
const QStringList groupList = sc.groupList();
for (const QString &group : groupList) {
- QVERIFY(!group.isEmpty() && group != "<default>");
+ QVERIFY(!group.isEmpty() && group != QLatin1String("<default>"));
}
defaultGroup.deleteGroup();
@@ -917,30 +909,30 @@ void KConfigTest::testDefaultGroup()
void KConfigTest::testEmptyGroup()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup emptyGroup(&sc, "");
- QCOMPARE(emptyGroup.name(), QString("<default>")); // confusing, heh?
+ QCOMPARE(emptyGroup.name(), QStringLiteral("<default>")); // confusing, heh?
QVERIFY(!emptyGroup.exists());
emptyGroup.writeEntry("TestKey", "emptyGroup");
QVERIFY(emptyGroup.exists());
- QCOMPARE(emptyGroup.readEntry("TestKey", QString()), QString("emptyGroup"));
+ QCOMPARE(emptyGroup.readEntry("TestKey", QString{}), QStringLiteral("emptyGroup"));
QVERIFY(sc.sync());
{
// Test reading it
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup defaultGroup(&sc2, "<default>");
- QCOMPARE(defaultGroup.name(), QString("<default>"));
+ QCOMPARE(defaultGroup.name(), QStringLiteral("<default>"));
QVERIFY(defaultGroup.exists());
- QCOMPARE(defaultGroup.readEntry("TestKey", QString()), QString("emptyGroup"));
+ QCOMPARE(defaultGroup.readEntry("TestKey", QString{}), QStringLiteral("emptyGroup"));
}
{
// Test reading it
- KConfig sc2(TEST_SUBDIR "kconfigtest");
+ KConfig sc2(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup emptyGroup2(&sc2, "");
- QCOMPARE(emptyGroup2.name(), QString("<default>"));
+ QCOMPARE(emptyGroup2.name(), QStringLiteral("<default>"));
QVERIFY(emptyGroup2.exists());
- QCOMPARE(emptyGroup2.readEntry("TestKey", QString()), QString("emptyGroup"));
+ QCOMPARE(emptyGroup2.readEntry("TestKey", QString{}), QStringLiteral("emptyGroup"));
}
QList<QByteArray> lines = readLines();
@@ -950,7 +942,7 @@ void KConfigTest::testEmptyGroup()
// Now that the group exists make sure it isn't returned from groupList()
const QStringList groupList = sc.groupList();
for (const QString &group : groupList) {
- QVERIFY(!group.isEmpty() && group != "<default>");
+ QVERIFY(!group.isEmpty() && group != QLatin1String("<default>"));
}
emptyGroup.deleteGroup();
QVERIFY(sc.sync());
@@ -971,11 +963,11 @@ void KConfigTest::testCascadingWithLocale()
#ifdef Q_XDG_PLATFORM
QTemporaryDir middleDir;
QTemporaryDir globalDir;
- qputenv("XDG_CONFIG_DIRS", qPrintable(middleDir.path() + QString(":") + globalDir.path()));
+ qputenv("XDG_CONFIG_DIRS", qPrintable(middleDir.path() + QLatin1Char(':') + globalDir.path()));
- const QString globalConfigDir = globalDir.path() + "/" TEST_SUBDIR;
+ const QString globalConfigDir = globalDir.path() + QLatin1Char('/') + TEST_SUBDIR;
QVERIFY(QDir().mkpath(globalConfigDir));
- QFile global(globalConfigDir + "foo.desktop");
+ QFile global(globalConfigDir + QLatin1String("foo.desktop"));
QVERIFY(global.open(QIODevice::WriteOnly | QIODevice::Text));
QTextStream globalOut(&global);
globalOut << "[Group]\n"
@@ -987,9 +979,9 @@ void KConfigTest::testCascadingWithLocale()
<< "Other[fr]=Global_FR\n";
global.close();
- const QString middleConfigDir = middleDir.path() + "/" TEST_SUBDIR;
+ const QString middleConfigDir = middleDir.path() + QLatin1Char('/') + TEST_SUBDIR;
QVERIFY(QDir().mkpath(middleConfigDir));
- QFile local(middleConfigDir + "foo.desktop");
+ QFile local(middleConfigDir + QLatin1String("foo.desktop"));
QVERIFY(local.open(QIODevice::WriteOnly | QIODevice::Text));
QTextStream out(&local);
out << "[Group]\n"
@@ -1000,16 +992,16 @@ void KConfigTest::testCascadingWithLocale()
<< "Other=English Only\n";
local.close();
- KConfig config(TEST_SUBDIR "foo.desktop");
+ KConfig config(TEST_SUBDIR + QLatin1String("foo.desktop"));
KConfigGroup group = config.group("Group");
- QCOMPARE(group.readEntry("FromGlobal"), QString("true"));
- QCOMPARE(group.readEntry("FromLocal"), QString("true"));
- QCOMPARE(group.readEntry("Name"), QString("Local Testing"));
+ QCOMPARE(group.readEntry("FromGlobal"), QStringLiteral("true"));
+ QCOMPARE(group.readEntry("FromLocal"), QStringLiteral("true"));
+ QCOMPARE(group.readEntry("Name"), QStringLiteral("Local Testing"));
config.setLocale(QStringLiteral("fr"));
- QCOMPARE(group.readEntry("FromGlobal"), QString("vrai"));
- QCOMPARE(group.readEntry("FromLocal"), QString("vrai"));
- QCOMPARE(group.readEntry("Name"), QString("FR"));
- QCOMPARE(group.readEntry("Other"), QString("English Only")); // Global_FR is locally overriden
+ QCOMPARE(group.readEntry("FromGlobal"), QStringLiteral("vrai"));
+ QCOMPARE(group.readEntry("FromLocal"), QStringLiteral("vrai"));
+ QCOMPARE(group.readEntry("Name"), QStringLiteral("FR"));
+ QCOMPARE(group.readEntry("Other"), QStringLiteral("English Only")); // Global_FR is locally overriden
#endif
}
@@ -1017,7 +1009,7 @@ void KConfigTest::testMerge()
{
DefaultLocale defaultLocale;
QLocale::setDefault(QLocale::c());
- KConfig config(TEST_SUBDIR "mergetest", KConfig::SimpleConfig);
+ KConfig config(TEST_SUBDIR + QLatin1String("mergetest"), KConfig::SimpleConfig);
KConfigGroup cg = config.group("some group");
cg.writeEntry("entry", " random entry");
@@ -1025,7 +1017,7 @@ void KConfigTest::testMerge()
{
// simulate writing by another process
- QFile file(testConfigDir() + "/mergetest");
+ QFile file(m_testConfigDir + QLatin1String("/mergetest"));
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -1054,7 +1046,7 @@ void KConfigTest::testMerge()
<< "entry[de]=German\n"
<< "entry[es]=Spanish\n"
<< "entry[fr]=French\n";
- QFile file(testConfigDir() + "/mergetest");
+ QFile file(m_testConfigDir + QLatin1String("/mergetest"));
file.open(QIODevice::ReadOnly | QIODevice::Text);
for (const QByteArray &line : qAsConst(lines)) {
QCOMPARE(line, file.readLine());
@@ -1065,7 +1057,7 @@ void KConfigTest::testMerge()
void KConfigTest::testImmutable()
{
{
- QFile file(testConfigDir() + "/immutabletest");
+ QFile file(m_testConfigDir + QLatin1String("/immutabletest"));
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -1077,7 +1069,7 @@ void KConfigTest::testImmutable()
<< "[group][subgroup][$i]\n";
}
- KConfig config(TEST_SUBDIR "immutabletest", KConfig::SimpleConfig);
+ KConfig config(TEST_SUBDIR + QLatin1String("immutabletest"), KConfig::SimpleConfig);
QVERIFY(config.isGroupImmutable(QByteArray()));
KConfigGroup cg = config.group(QByteArray());
QVERIFY(cg.isEntryImmutable("entry1"));
@@ -1092,7 +1084,7 @@ void KConfigTest::testImmutable()
void KConfigTest::testOptionOrder()
{
{
- QFile file(testConfigDir() + "/doubleattrtest");
+ QFile file(m_testConfigDir + QLatin1String("/doubleattrtest"));
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -1102,14 +1094,14 @@ void KConfigTest::testOptionOrder()
<< "entry2=unlocalized\n"
<< "entry2[$i][de_DE]=t2\n";
}
- KConfig config(TEST_SUBDIR "doubleattrtest", KConfig::SimpleConfig);
+ KConfig config(TEST_SUBDIR + QLatin1String("doubleattrtest"), KConfig::SimpleConfig);
config.setLocale(QStringLiteral("de_DE"));
KConfigGroup cg3 = config.group("group3");
QVERIFY(!cg3.isImmutable());
- QCOMPARE(cg3.readEntry("entry2", ""), QString("t2"));
+ QCOMPARE(cg3.readEntry("entry2", ""), QStringLiteral("t2"));
QVERIFY(cg3.isEntryImmutable("entry2"));
config.setLocale(QStringLiteral("C"));
- QCOMPARE(cg3.readEntry("entry2", ""), QString("unlocalized"));
+ QCOMPARE(cg3.readEntry("entry2", ""), QStringLiteral("unlocalized"));
QVERIFY(!cg3.isEntryImmutable("entry2"));
cg3.writeEntry("entry2", "modified");
QVERIFY(config.sync());
@@ -1121,7 +1113,7 @@ void KConfigTest::testOptionOrder()
<< "entry2=modified\n"
<< "entry2[de_DE][$i]=t2\n";
- QFile file(testConfigDir() + "/doubleattrtest");
+ QFile file(m_testConfigDir + QLatin1String("/doubleattrtest"));
file.open(QIODevice::ReadOnly | QIODevice::Text);
for (const QByteArray &line : qAsConst(lines)) {
QCOMPARE(line, file.readLine());
@@ -1131,35 +1123,35 @@ void KConfigTest::testOptionOrder()
void KConfigTest::testGroupEscape()
{
- KConfig config(TEST_SUBDIR "groupescapetest", KConfig::SimpleConfig);
+ KConfig config(TEST_SUBDIR + QLatin1String("groupescapetest"), KConfig::SimpleConfig);
QVERIFY(config.group(DOLLARGROUP).exists());
}
void KConfigTest::testSubGroup()
{
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup cg(&sc, "ParentGroup");
- QCOMPARE(cg.readEntry("parentgrpstring", ""), QString("somevalue"));
+ QCOMPARE(cg.readEntry("parentgrpstring", ""), QStringLiteral("somevalue"));
KConfigGroup subcg1(&cg, "SubGroup1");
- QCOMPARE(subcg1.name(), QString("SubGroup1"));
- QCOMPARE(subcg1.readEntry("somestring", ""), QString("somevalue"));
+ QCOMPARE(subcg1.name(), QStringLiteral("SubGroup1"));
+ QCOMPARE(subcg1.readEntry("somestring", ""), QStringLiteral("somevalue"));
KConfigGroup subcg2(&cg, "SubGroup2");
- QCOMPARE(subcg2.name(), QString("SubGroup2"));
- QCOMPARE(subcg2.readEntry("substring", ""), QString("somevalue"));
+ QCOMPARE(subcg2.name(), QStringLiteral("SubGroup2"));
+ QCOMPARE(subcg2.readEntry("substring", ""), QStringLiteral("somevalue"));
KConfigGroup subcg3(&cg, "SubGroup/3");
- QCOMPARE(subcg3.readEntry("sub3string", ""), QString("somevalue"));
- QCOMPARE(subcg3.name(), QString("SubGroup/3"));
+ QCOMPARE(subcg3.readEntry("sub3string", ""), QStringLiteral("somevalue"));
+ QCOMPARE(subcg3.name(), QStringLiteral("SubGroup/3"));
KConfigGroup rcg(&sc, "");
KConfigGroup srcg(&rcg, "ParentGroup");
- QCOMPARE(srcg.readEntry("parentgrpstring", ""), QString("somevalue"));
+ QCOMPARE(srcg.readEntry("parentgrpstring", ""), QStringLiteral("somevalue"));
QStringList groupList = cg.groupList();
groupList.sort(); // comes from QSet, so order is undefined
- QCOMPARE(groupList, (QStringList() << "SubGroup/3" << "SubGroup1" << "SubGroup2"));
+ QCOMPARE(groupList, (QStringList{QStringLiteral("SubGroup/3"), QStringLiteral("SubGroup1"), QStringLiteral("SubGroup2")}));
- const QStringList expectedSubgroup3Keys = (QStringList() << QStringLiteral("sub3string"));
+ const QStringList expectedSubgroup3Keys{QStringLiteral("sub3string")};
QCOMPARE(subcg3.keyList(), expectedSubgroup3Keys);
- const QStringList expectedParentGroupKeys(QStringList() << QStringLiteral("parentgrpstring"));
+ const QStringList expectedParentGroupKeys{QStringLiteral("parentgrpstring")};
QCOMPARE(cg.keyList(), expectedParentGroupKeys);
@@ -1199,15 +1191,15 @@ void KConfigTest::testSubGroup()
// This is what happens
QStringList groups = neg.groupList();
groups.sort(); // Qt5 made the ordering unreliable, due to QHash
- QCOMPARE(groups, QStringList() << "NEG Child1" << "NEG Child4");
+ QCOMPARE(groups, (QStringList{QStringLiteral("NEG Child1"), QStringLiteral("NEG Child4")}));
// make sure groupList() isn't returning something it shouldn't
const QStringList listGroup = sc.groupList();
for (const QString &group : listGroup) {
- QVERIFY(!group.isEmpty() && group != "<default>");
+ QVERIFY(!group.isEmpty() && group != QLatin1String("<default>"));
QVERIFY(!group.contains(QChar(0x1d)));
- QVERIFY(!group.contains("subgroup"));
- QVERIFY(!group.contains("SubGroup"));
+ QVERIFY(!group.contains(QLatin1String("subgroup")));
+ QVERIFY(!group.contains(QLatin1String("SubGroup")));
}
QVERIFY(sc.sync());
@@ -1223,21 +1215,21 @@ void KConfigTest::testSubGroup()
void KConfigTest::testAddConfigSources()
{
- KConfig cf(TEST_SUBDIR "specificrc");
+ KConfig cf(TEST_SUBDIR + QLatin1String("specificrc"));
- cf.addConfigSources(QStringList() << testConfigDir() + "/baserc");
+ cf.addConfigSources(QStringList{m_testConfigDir + QLatin1String("/baserc")});
cf.reparseConfiguration();
KConfigGroup specificgrp(&cf, "Specific Only Group");
- QCOMPARE(specificgrp.readEntry("ExistingEntry", ""), QString("DevValue"));
+ QCOMPARE(specificgrp.readEntry("ExistingEntry", ""), QStringLiteral("DevValue"));
KConfigGroup sharedgrp(&cf, "Shared Group");
- QCOMPARE(sharedgrp.readEntry("SomeSpecificOnlyEntry", ""), QString("DevValue"));
- QCOMPARE(sharedgrp.readEntry("SomeBaseOnlyEntry", ""), QString("BaseValue"));
- QCOMPARE(sharedgrp.readEntry("SomeSharedEntry", ""), QString("DevValue"));
+ QCOMPARE(sharedgrp.readEntry("SomeSpecificOnlyEntry", ""), QStringLiteral("DevValue"));
+ QCOMPARE(sharedgrp.readEntry("SomeBaseOnlyEntry", ""), QStringLiteral("BaseValue"));
+ QCOMPARE(sharedgrp.readEntry("SomeSharedEntry", ""), QStringLiteral("DevValue"));
KConfigGroup basegrp(&cf, "Base Only Group");
- QCOMPARE(basegrp.readEntry("ExistingEntry", ""), QString("BaseValue"));
+ QCOMPARE(basegrp.readEntry("ExistingEntry", ""), QStringLiteral("BaseValue"));
basegrp.writeEntry("New Entry Base Only", "SomeValue");
KConfigGroup newgrp(&cf, "New Group");
@@ -1245,25 +1237,25 @@ void KConfigTest::testAddConfigSources()
QVERIFY(cf.sync());
- KConfig plaincfg(TEST_SUBDIR "specificrc");
+ KConfig plaincfg(TEST_SUBDIR + QLatin1String("specificrc"));
KConfigGroup newgrp2(&plaincfg, "New Group");
- QCOMPARE(newgrp2.readEntry("New Entry", ""), QString("SomeValue"));
+ QCOMPARE(newgrp2.readEntry("New Entry", ""), QStringLiteral("SomeValue"));
KConfigGroup basegrp2(&plaincfg, "Base Only Group");
- QCOMPARE(basegrp2.readEntry("New Entry Base Only", ""), QString("SomeValue"));
+ QCOMPARE(basegrp2.readEntry("New Entry Base Only", ""), QStringLiteral("SomeValue"));
}
void KConfigTest::testGroupCopyTo()
{
- KConfig cf1(TEST_SUBDIR "kconfigtest");
+ KConfig cf1(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup original = cf1.group("Enum Types");
KConfigGroup copy = cf1.group("Enum Types Copy");
original.copyTo(&copy); // copy from one group to another
QCOMPARE(copy.entryMap(), original.entryMap());
- KConfig cf2(TEST_SUBDIR "copy_of_kconfigtest", KConfig::SimpleConfig);
+ KConfig cf2(TEST_SUBDIR + QLatin1String("copy_of_kconfigtest"), KConfig::SimpleConfig);
QVERIFY(!cf2.hasGroup(original.name()));
QVERIFY(!cf2.hasGroup(copy.name()));
@@ -1276,23 +1268,23 @@ void KConfigTest::testGroupCopyTo()
void KConfigTest::testConfigCopyToSync()
{
- KConfig cf1(TEST_SUBDIR "kconfigtest");
+ KConfig cf1(TEST_SUBDIR + QLatin1String("kconfigtest"));
// Prepare source file
KConfigGroup group(&cf1, "CopyToTest");
group.writeEntry("Type", "Test");
QVERIFY(cf1.sync());
// Copy to "destination"
- const QString destination = testConfigDir() + "/kconfigcopytotest";
+ const QString destination = m_testConfigDir + QLatin1String("/kconfigcopytotest");
QFile::remove(destination);
- KConfig cf2(TEST_SUBDIR "kconfigcopytotest");
+ KConfig cf2(TEST_SUBDIR + QLatin1String("kconfigcopytotest"));
KConfigGroup group2(&cf2, "CopyToTest");
group.copyTo(&group2);
QString testVal = group2.readEntry("Type");
- QCOMPARE(testVal, QString("Test"));
+ QCOMPARE(testVal, QStringLiteral("Test"));
// should write to disk the copied data from group
QVERIFY(cf2.sync());
QVERIFY(QFile::exists(destination));
@@ -1300,7 +1292,7 @@ void KConfigTest::testConfigCopyToSync()
void KConfigTest::testConfigCopyTo()
{
- KConfig cf1(TEST_SUBDIR "kconfigtest");
+ KConfig cf1(TEST_SUBDIR + QLatin1String("kconfigtest"));
{
// Prepare source file
KConfigGroup group(&cf1, "CopyToTest");
@@ -1310,27 +1302,27 @@ void KConfigTest::testConfigCopyTo()
{
// Copy to "destination"
- const QString destination = testConfigDir() + "/kconfigcopytotest";
+ const QString destination = m_testConfigDir + QLatin1String("/kconfigcopytotest");
QFile::remove(destination);
KConfig cf2;
cf1.copyTo(destination, &cf2);
KConfigGroup group2(&cf2, "CopyToTest");
QString testVal = group2.readEntry("Type");
- QCOMPARE(testVal, QString("Test"));
+ QCOMPARE(testVal, QStringLiteral("Test"));
QVERIFY(cf2.sync());
QVERIFY(QFile::exists(destination));
}
// Check copied config file on disk
- KConfig cf3(TEST_SUBDIR "kconfigcopytotest");
+ KConfig cf3(TEST_SUBDIR + QLatin1String("kconfigcopytotest"));
KConfigGroup group3(&cf3, "CopyToTest");
QString testVal = group3.readEntry("Type");
- QCOMPARE(testVal, QString("Test"));
+ QCOMPARE(testVal, QStringLiteral("Test"));
}
void KConfigTest::testReparent()
{
- KConfig cf(TEST_SUBDIR "kconfigtest");
+ KConfig cf(TEST_SUBDIR + QLatin1String("kconfigtest"));
const QString name(QStringLiteral("Enum Types"));
KConfigGroup group = cf.group(name);
const QMap<QString, QString> originalMap = group.entryMap();
@@ -1356,7 +1348,7 @@ static void ageTimeStamp(const QString &path, int nsec)
struct utimbuf utbuf;
utbuf.actime = mtime.toSecsSinceEpoch();
utbuf.modtime = utbuf.actime;
- utime(QFile::encodeName(path), &utbuf);
+ utime(QFile::encodeName(path).constData(), &utbuf);
#else
QTest::qSleep(nsec * 1000);
#endif
@@ -1365,10 +1357,10 @@ static void ageTimeStamp(const QString &path, int nsec)
void KConfigTest::testWriteOnSync()
{
QDateTime oldStamp, newStamp;
- KConfig sc(TEST_SUBDIR "kconfigtest", KConfig::IncludeGlobals);
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"), KConfig::IncludeGlobals);
// Age the timestamp of global config file a few sec, and collect it.
- QString globFile = kdeGlobalsPath();
+ QString globFile = m_kdeGlobalsPath;
ageTimeStamp(globFile, 2); // age 2 sec
oldStamp = QFileInfo(globFile).lastModified();
@@ -1383,7 +1375,7 @@ void KConfigTest::testWriteOnSync()
QCOMPARE(newStamp, oldStamp);
// Age the timestamp of local config file a few sec, and collect it.
- QString locFile = testConfigDir() + "/kconfigtest";
+ QString locFile = m_testConfigDir + QLatin1String("/kconfigtest");
ageTimeStamp(locFile, 2); // age 2 sec
oldStamp = QFileInfo(locFile).lastModified();
@@ -1401,13 +1393,13 @@ void KConfigTest::testWriteOnSync()
void KConfigTest::testFailOnReadOnlyFileSync()
{
- KConfig sc(TEST_SUBDIR "kconfigfailonreadonlytest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigfailonreadonlytest"));
KConfigGroup cgLocal(&sc, "Locals");
cgLocal.writeEntry("someLocalString", "whatever");
QVERIFY(cgLocal.sync());
- QFile f(testConfigDir() + "kconfigfailonreadonlytest");
+ QFile f(m_testConfigDir + QLatin1String("kconfigfailonreadonlytest"));
QVERIFY(f.exists());
QVERIFY(f.setPermissions(QFileDevice::ReadOwner));
@@ -1425,7 +1417,7 @@ void KConfigTest::testFailOnReadOnlyFileSync()
void KConfigTest::testDirtyOnEqual()
{
QDateTime oldStamp, newStamp;
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
// Initialize value
KConfigGroup cgLocal(&sc, "random");
@@ -1433,7 +1425,7 @@ void KConfigTest::testDirtyOnEqual()
QVERIFY(sc.sync());
// Age the timestamp of local config file a few sec, and collect it.
- QString locFile = testConfigDir() + "/kconfigtest";
+ QString locFile = m_testConfigDir + QLatin1String("/kconfigtest");
ageTimeStamp(locFile, 2); // age 2 sec
oldStamp = QFileInfo(locFile).lastModified();
@@ -1453,7 +1445,7 @@ void KConfigTest::testDirtyOnEqualOverdo()
QByteArray val2("\0""two", 4);
QByteArray defvalr;
- KConfig sc(TEST_SUBDIR "kconfigtest");
+ KConfig sc(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigGroup cgLocal(&sc, "random");
cgLocal.writeEntry("someKey", val1);
QCOMPARE(cgLocal.readEntry("someKey", defvalr), val1);
@@ -1464,9 +1456,9 @@ void KConfigTest::testDirtyOnEqualOverdo()
void KConfigTest::testCreateDir()
{
// Test auto-creating the parent directory when needed (KConfigIniBackend::createEnclosing)
- QString kdehome = QDir::home().canonicalPath() + "/.kde-unit-test";
- QString subdir = kdehome + "/newsubdir";
- QString file = subdir + "/foo.desktop";
+ const QString kdehome = QDir::home().canonicalPath() + QLatin1String("/.kde-unit-test");
+ const QString subdir = kdehome + QLatin1String("/newsubdir");
+ const QString file = subdir + QLatin1String("/foo.desktop");
QFile::remove(file);
QDir().rmdir(subdir);
QVERIFY(!QDir().exists(subdir));
@@ -1485,7 +1477,7 @@ void KConfigTest::testSyncOnExit()
// Often, the KGlobalPrivate global static's destructor ends up calling ~KConfig ->
// KConfig::sync ... and if that code triggers KGlobal code again then things could crash.
// So here's a test for modifying KSharedConfig::openConfig() and not syncing, the process exit will sync.
- KConfigGroup grp(KSharedConfig::openConfig(TEST_SUBDIR "syncOnExitRc"), "syncOnExit");
+ KConfigGroup grp(KSharedConfig::openConfig(TEST_SUBDIR + QLatin1String("syncOnExitRc")), "syncOnExit");
grp.writeEntry("key", "value");
}
@@ -1494,24 +1486,22 @@ void KConfigTest::testSharedConfig()
// Can I use a KConfigGroup even after the KSharedConfigPtr goes out of scope?
KConfigGroup myConfigGroup;
{
- KSharedConfigPtr config = KSharedConfig::openConfig(TEST_SUBDIR "kconfigtest");
+ KSharedConfigPtr config = KSharedConfig::openConfig(TEST_SUBDIR + QLatin1String("kconfigtest"));
myConfigGroup = KConfigGroup(config, "Hello");
}
- QCOMPARE(myConfigGroup.readEntry("stringEntry1"), QString(STRINGENTRY1));
+ QCOMPARE(myConfigGroup.readEntry("stringEntry1"), STRINGENTRY1);
// Get the main config
KSharedConfigPtr mainConfig = KSharedConfig::openConfig();
KConfigGroup mainGroup(mainConfig, "Main");
- QCOMPARE(mainGroup.readEntry("Key", QString()), QString("Value"));
+ QCOMPARE(mainGroup.readEntry("Key", QString{}), QStringLiteral("Value"));
}
void KConfigTest::testLocaleConfig()
{
// Initialize the testdata
- QDir dir;
- QString subdir = testConfigDir();
- dir.mkpath(subdir);
- QString file = subdir + "/localized.test";
+ QDir().mkpath(m_testConfigDir);
+ const QString file = m_testConfigDir + QLatin1String("/localized.test");
QFile::remove(file);
QFile f(file);
QVERIFY(f.open(QIODevice::WriteOnly));
@@ -1546,11 +1536,11 @@ void KConfigTest::testLocaleConfig()
// Now check the correct config group
KConfigGroup cg2(&config, "Test_Right");
- QCOMPARE(cg2.readEntry("foo"), QString("5"));
+ QCOMPARE(cg2.readEntry("foo"), QStringLiteral("5"));
QCOMPARE(cg2.readEntry("foo", 3), 5);
- QCOMPARE(cg2.readEntry("foostring"), QString("nice"));
- QCOMPARE(cg2.readEntry("foostring", "ugly"), QString("nice"));
- QCOMPARE(cg2.readEntry("foobool"), QString("true"));
+ QCOMPARE(cg2.readEntry("foostring"), QStringLiteral("nice"));
+ QCOMPARE(cg2.readEntry("foostring", "ugly"), QStringLiteral("nice"));
+ QCOMPARE(cg2.readEntry("foobool"), QStringLiteral("true"));
QCOMPARE(cg2.readEntry("foobool", false), true);
// Clean up after the testcase
@@ -1560,10 +1550,9 @@ void KConfigTest::testLocaleConfig()
void KConfigTest::testDeleteWhenLocalized()
{
// Initialize the testdata
- QDir dir;
- QString subdir = QDir::home().canonicalPath() + "/.kde-unit-test/";
- dir.mkpath(subdir);
- QString file = subdir + "/localized_delete.test";
+ const QString subdir = QDir::home().canonicalPath() + QLatin1String("/.kde-unit-test/");
+ QDir().mkpath(subdir);
+ const QString file = subdir + QLatin1String("/localized_delete.test");
QFile::remove(file);
QFile f(file);
QVERIFY(f.open(QIODevice::WriteOnly));
@@ -1615,7 +1604,7 @@ void KConfigTest::testDeleteWhenLocalized()
QVERIFY(cg.hasKey("foo"));
// Check where the wrong values come from.
// We get the "de" value.
- QCOMPARE(cg.readEntry("foostring", "nothing"), QString("schoen"));
+ QCOMPARE(cg.readEntry("foostring", "nothing"), QStringLiteral("schoen"));
// We get the "de" value.
QCOMPARE(cg.readEntry("foobool", false), true);
@@ -1631,7 +1620,7 @@ void KConfigTest::testDeleteWhenLocalized()
QVERIFY(cg.hasKey("foo"));
// Check where the wrong values come from.
// We get the primary value because the "ca" value was deleted.
- QCOMPARE(cg.readEntry("foostring", "nothing"), QString("ugly"));
+ QCOMPARE(cg.readEntry("foostring", "nothing"), QStringLiteral("ugly"));
// We get the "ca" value.
QCOMPARE(cg.readEntry("foobool", false), true);
@@ -1660,7 +1649,7 @@ void KConfigTest::testDeleteWhenLocalized()
QVERIFY(!cg.hasKey("foobool"));
// Check where the wrong values come from.
// We get the "de" value.
- QCOMPARE(cg.readEntry("foostring", "nothing"), QString("schoen"));
+ QCOMPARE(cg.readEntry("foostring", "nothing"), QStringLiteral("schoen"));
// We get the "de" value.
QCOMPARE(cg.readEntry("foobool", false), true);
// We get the "de" value.
@@ -1696,10 +1685,10 @@ void KConfigTest::testKdeGlobals()
KConfig globRead(QStringLiteral("kdeglobals"));
const KConfigGroup general(&globRead, "General");
- QCOMPARE(general.readEntry("testKG"), QString("1"));
+ QCOMPARE(general.readEntry("testKG"), QStringLiteral("1"));
// Check we wrote into kdeglobals
- const QList<QByteArray> lines = readLines("kdeglobals");
+ const QList<QByteArray> lines = readLines(QStringLiteral("kdeglobals"));
QVERIFY(lines.contains("[General]\n"));
QVERIFY(lines.contains("testKG=1\n"));
@@ -1711,13 +1700,13 @@ void KConfigTest::testKdeGlobals()
QVERIFY(glob.sync());
}
globRead.reparseConfiguration();
- QCOMPARE(general.readEntry("testKG"), QString("2"));
+ QCOMPARE(general.readEntry("testKG"), QStringLiteral("2"));
// Reading using NoGlobals
{
KConfig globReadNoGlob(QStringLiteral("kdeglobals"), KConfig::NoGlobals);
const KConfigGroup generalNoGlob(&globReadNoGlob, "General");
- QCOMPARE(generalNoGlob.readEntry("testKG"), QString("2"));
+ QCOMPARE(generalNoGlob.readEntry("testKG"), QStringLiteral("2"));
}
// TODO now use kconfigtest and writeEntry(,Global) -> should go into kdeglobals
@@ -1729,7 +1718,7 @@ void KConfigTest::testAnonymousConfig()
KConfigGroup general(&anonConfig, "General");
QCOMPARE(general.readEntry("testKG"), QString()); // no kdeglobals merging
general.writeEntry("Foo", "Bar");
- QCOMPARE(general.readEntry("Foo"), QString("Bar"));
+ QCOMPARE(general.readEntry("Foo"), QStringLiteral("Bar"));
}
void KConfigTest::testQByteArrayUtf8()
@@ -1853,12 +1842,12 @@ void KConfigTest::testXdgListEntry()
KConfigGroup grp = anonConfig.group("General");
QStringList invalidList; // use this as a default when an empty list is expected
invalidList << QStringLiteral("Error! Default value read!");
- QCOMPARE(grp.readXdgListEntry("Key1", invalidList), QStringList());
- QCOMPARE(grp.readXdgListEntry("Key2", invalidList), QStringList() << QString());
- QCOMPARE(grp.readXdgListEntry("Key3", invalidList), QStringList() << QString() << QString());
- QCOMPARE(grp.readXdgListEntry("Key4", invalidList), QStringList()<< QString() << QString() << QString());
- QCOMPARE(grp.readXdgListEntry("Key5", invalidList), QStringList() << ";");
- QCOMPARE(grp.readXdgListEntry("Key6", invalidList), QStringList() << "1" << "2;3" << QString());
+ QCOMPARE(grp.readXdgListEntry("Key1", invalidList), (QStringList{}));
+ QCOMPARE(grp.readXdgListEntry("Key2", invalidList), (QStringList{QString{}}));
+ QCOMPARE(grp.readXdgListEntry("Key3", invalidList), (QStringList{QString{}, QString{}}));
+ QCOMPARE(grp.readXdgListEntry("Key4", invalidList), (QStringList{QString{}, QString{}, QString{}}));
+ QCOMPARE(grp.readXdgListEntry("Key5", invalidList), (QStringList{QStringLiteral(";")}));
+ QCOMPARE(grp.readXdgListEntry("Key6", invalidList), (QStringList{QStringLiteral("1"), QStringLiteral("2;3"), QString{}}));
}
#include <QThreadPool>
@@ -1890,15 +1879,15 @@ void KConfigTest::testNotify()
QSKIP("KConfig notification requires DBus");
#endif
- KConfig config(TEST_SUBDIR "kconfigtest");
+ KConfig config(TEST_SUBDIR + QLatin1String("kconfigtest"));
auto myConfigGroup = KConfigGroup(&config, "TopLevelGroup");
//mimics a config in another process, which is watching for events
- auto remoteConfig = KSharedConfig::openConfig(TEST_SUBDIR "kconfigtest");
+ auto remoteConfig = KSharedConfig::openConfig(TEST_SUBDIR + QLatin1String("kconfigtest"));
KConfigWatcher::Ptr watcher = KConfigWatcher::create(remoteConfig);
//some random config that shouldn't be changing when kconfigtest changes, only on kdeglobals
- auto otherRemoteConfig = KSharedConfig::openConfig(TEST_SUBDIR "kconfigtest2");
+ auto otherRemoteConfig = KSharedConfig::openConfig(TEST_SUBDIR + QLatin1String("kconfigtest2"));
KConfigWatcher::Ptr otherWatcher = KConfigWatcher::create(otherRemoteConfig);
QSignalSpy watcherSpy(watcher.data(), &KConfigWatcher::configChanged);
@@ -1974,21 +1963,21 @@ void KConfigTest::testKdeglobalsVsDefault()
generalGlob.writeEntry("testRestore", "global");
QVERIFY(glob.sync());
- KConfig local(QStringLiteral(TEST_SUBDIR "restorerc"));
+ KConfig local(TEST_SUBDIR + QLatin1String("restorerc"));
KConfigGroup generalLocal(&local, "General");
// Check if we get global and not the default value from cpp (defaultcpp) when reading data from restorerc
- QCOMPARE(generalLocal.readEntry("testRestore", "defaultcpp"), "global");
+ QCOMPARE(generalLocal.readEntry("testRestore", "defaultcpp"), QStringLiteral("global"));
// Add test restore key with restore value in restorerc file
generalLocal.writeEntry("testRestore", "restore");
QVERIFY(local.sync());
local.reparseConfiguration();
// We expect to get the value from restorerc file
- QCOMPARE(generalLocal.readEntry("testRestore", "defaultcpp"), "restore");
+ QCOMPARE(generalLocal.readEntry("testRestore", "defaultcpp"), QStringLiteral("restore"));
// Revert to default testRestore key and we expect to get default value and not the global one
generalLocal.revertToDefault("testRestore");
local.sync();
local.reparseConfiguration();
- QCOMPARE(generalLocal.readEntry("testRestore", "defaultcpp"), "defaultcpp");
+ QCOMPARE(generalLocal.readEntry("testRestore", "defaultcpp"), QStringLiteral("defaultcpp"));
}
diff --git a/autotests/kconfigtest.h b/autotests/kconfigtest.h
index 7617d0e7..1a248c74 100644
--- a/autotests/kconfigtest.h
+++ b/autotests/kconfigtest.h
@@ -77,6 +77,10 @@ private Q_SLOTS:
// should be last
void testSyncOnExit();
+
+private:
+ QString m_testConfigDir;
+ QString m_kdeGlobalsPath;
};
Q_DECLARE_OPERATORS_FOR_FLAGS(KConfigTest::Flags)
generated by cgit v1.2.1 (git 2.18.0) at 2025-10-31 14:52:06 +0000