diff options
Diffstat (limited to 'autotests/kconfigtest.cpp')
| -rw-r--r-- | autotests/kconfigtest.cpp | 1634 |
1 files changed, 1634 insertions, 0 deletions
diff --git a/autotests/kconfigtest.cpp b/autotests/kconfigtest.cpp new file mode 100644 index 00000000..1aed5151 --- /dev/null +++ b/autotests/kconfigtest.cpp @@ -0,0 +1,1634 @@ +/* This file is part of the KDE libraries + Copyright (C) 1997 Matthias Kalle Dalheimer (kalle@kde.org) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// 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 <QtTest/QtTest> +#include <qtemporarydir.h> +#include <QStandardPaths> +#include <kdesktopfile.h> + +#include <ksharedconfig.h> +#include <kconfiggroup.h> + +#ifdef Q_OS_UNIX +#include <utime.h> +#endif +#ifndef Q_OS_WIN +#include <unistd.h> // gethostname +#endif + +KCONFIGGROUP_DECLARE_ENUM_QOBJECT(KConfigTest,Testing) +KCONFIGGROUP_DECLARE_FLAGS_QOBJECT(KConfigTest,Flags) + +QTEST_MAIN( KConfigTest ) + +#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 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(QDir::homePath()+"/foo") +#define HOMEPATHESCAPE QString(QDir::homePath()+"/foo/$HOME") +#define DOLLARGROUP "$i" + +void KConfigTest::initTestCase() +{ + // ensure we don't use files in the real config directory + QStandardPaths::setTestModeEnabled(true); + QString testConfigDir = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation); + + // to make sure all files from a previous failed run are deleted + cleanupTestCase(); + + + KConfig sc( "kconfigtest" ); + + KConfigGroup cg(&sc, "AAA"); + cg.writeEntry("stringEntry1", STRINGENTRY1, + KConfig::Persistent|KConfig::Global); + cg.deleteEntry("stringEntry2", KConfig::Global); + + cg = KConfigGroup(&sc, "Hello"); + cg.writeEntry( "boolEntry1", BOOLENTRY1 ); + cg.writeEntry( "boolEntry2", BOOLENTRY2 ); + + QByteArray data( UTF8BITENTRY ); + QCOMPARE( data.size(), 12 ); // the source file is in utf8 + QCOMPARE( QString::fromUtf8(data).length(), 9 ); + cg.writeEntry ("Test", data); + cg.writeEntry( "bytearrayEntry", BYTEARRAYENTRY ); + cg.writeEntry( ESCAPEKEY, ESCAPEENTRY ); + cg.writeEntry( "emptyEntry", ""); + cg.writeEntry( "stringEntry1", STRINGENTRY1 ); + cg.writeEntry( "stringEntry2", STRINGENTRY2 ); + cg.writeEntry( "stringEntry3", STRINGENTRY3 ); + cg.writeEntry( "stringEntry4", STRINGENTRY4 ); + cg.writeEntry( "stringEntry5", STRINGENTRY5 ); + cg.writeEntry( "urlEntry1", QUrl("http://qt-project.org") ); + 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( "doubleEntry1", DOUBLEENTRY ); + cg.writeEntry( "floatEntry1", FLOATENTRY ); + + sc.deleteGroup("deleteMe"); // deleting a nonexistent group + + cg = KConfigGroup(&sc, "Complex Types"); + cg.writeEntry( "rectEntry", RECTENTRY ); + cg.writeEntry( "pointEntry", POINTENTRY ); + cg.writeEntry( "sizeEntry", SIZEENTRY ); + cg.writeEntry( "dateTimeEntry", DATETIMEENTRY ); + cg.writeEntry( "dateEntry", DATETIMEENTRY.date() ); + + KConfigGroup ct = cg; + cg = KConfigGroup(&ct, "Nested Group 1"); + cg.writeEntry("stringentry1", STRINGENTRY1); + + cg = KConfigGroup(&ct, "Nested Group 2"); + cg.writeEntry( "stringEntry2", STRINGENTRY2 ); + + cg = KConfigGroup(&cg, "Nested Group 2.1"); + cg.writeEntry( "stringEntry3", STRINGENTRY3 ); + + cg = KConfigGroup(&ct, "Nested Group 3"); + cg.writeEntry( "stringEntry3", STRINGENTRY3 ); + + cg = KConfigGroup(&sc, "List Types" ); + cg.writeEntry( "listOfIntsEntry1", INTLISTENTRY1 ); + cg.writeEntry( "listOfByteArraysEntry1", BYTEARRAYLISTENTRY1 ); + cg.writeEntry( "stringListEntry", STRINGLISTENTRY ); + cg.writeEntry( "stringListEmptyEntry", STRINGLISTEMPTYENTRY ); + cg.writeEntry( "stringListJustEmptyElement", STRINGLISTJUSTEMPTYELEMENT ); + cg.writeEntry( "stringListEmptyTrailingElement", STRINGLISTEMPTYTRAINLINGELEMENT ); + cg.writeEntry( "stringListEscapeOddEntry", STRINGLISTESCAPEODDENTRY ); + cg.writeEntry( "stringListEscapeEvenEntry", STRINGLISTESCAPEEVENENTRY ); + cg.writeEntry( "stringListEscapeCommaEntry", STRINGLISTESCAPECOMMAENTRY ); + cg.writeEntry( "variantListEntry", VARIANTLISTENTRY ); + + cg = KConfigGroup(&sc, "Path Type" ); + cg.writePathEntry( "homepath", HOMEPATH ); + cg.writePathEntry( "homepathescape", HOMEPATHESCAPE ); + + cg = KConfigGroup(&sc, "Enum Types" ); + writeEntry( cg, "enum-10", Tens ); + writeEntry( cg, "enum-100", Hundreds ); + writeEntry( cg, "flags-bit0", Flags(bit0)); + writeEntry( cg, "flags-bit0-bit1", Flags(bit0|bit1) ); + + cg = KConfigGroup(&sc, "ParentGroup" ); + KConfigGroup cg1(&cg, "SubGroup1" ); + cg1.writeEntry( "somestring", "somevalue" ); + cg.writeEntry( "parentgrpstring", "somevalue" ); + KConfigGroup cg2(&cg, "SubGroup2" ); + cg2.writeEntry( "substring", "somevalue" ); + KConfigGroup cg3(&cg, "SubGroup/3"); + cg3.writeEntry( "sub3string", "somevalue" ); + + QVERIFY(sc.isDirty()); + QVERIFY(sc.sync()); + QVERIFY(!sc.isDirty()); + + QVERIFY2(QFile::exists(testConfigDir + QStringLiteral("/kconfigtest")), + qPrintable(testConfigDir + QStringLiteral("/kconfigtest must exist"))); + QVERIFY2(QFile::exists(testConfigDir + QStringLiteral("/kdeglobals")), + qPrintable(testConfigDir + QStringLiteral("/kdeglobals must exist"))); + + + KConfig sc1("kdebugrc", KConfig::SimpleConfig); + KConfigGroup sg0(&sc1, "0"); + sg0.writeEntry("AbortFatal", false); + sg0.writeEntry("WarnOutput", 0); + sg0.writeEntry("FatalOutput", 0); + QVERIFY(sc1.sync()); + + //Setup stuff to test KConfig::addConfigSources() + KConfig devcfg("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("baserc"); + KConfigGroup basegrp(&basecfg, "Base Only Group"); + basegrp.writeEntry("ExistingEntry", "BaseValue"); + KConfigGroup baseanddevgrp(&basecfg, "Shared Group"); + baseanddevgrp.writeEntry("SomeSharedEntry", "BaseValue"); + baseanddevgrp.writeEntry("SomeBaseOnlyEntry", "BaseValue"); + QVERIFY(basecfg.sync()); + + KConfig gecfg("groupescapetest", KConfig::SimpleConfig); + cg = KConfigGroup(&gecfg, DOLLARGROUP); + cg.writeEntry( "entry", "doesntmatter" ); + +} + +void KConfigTest::cleanupTestCase() +{ + //ensure we don't delete the real directory + QStandardPaths::setTestModeEnabled(true); + QDir localConfig(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation)); + //qDebug() << "Erasing" << localConfig; + localConfig.removeRecursively(); + QVERIFY(!localConfig.exists()); +} + + +static QList<QByteArray> readLinesFrom(const QString& path) +{ + QFile file(path); + const bool opened = file.open(QIODevice::ReadOnly|QIODevice::Text); + Q_ASSERT(opened); + Q_UNUSED(opened); + QList<QByteArray> lines; + QByteArray line; + do { + line = file.readLine(); + if (!line.isEmpty()) + lines.append(line); + } while(!line.isEmpty()); + return lines; +} + +static QList<QByteArray> readLines(const char* fileName = "kconfigtest") +{ + const QString path = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + '/' + fileName; + Q_ASSERT(!path.isEmpty()); + return readLinesFrom(path); +} + +// see also testDefaults, which tests reverting with a defaults (global) file available +void KConfigTest::testDirtyAfterRevert() +{ + KConfig sc( "kconfigtest_revert" ); + + KConfigGroup cg(&sc, "Hello"); + cg.revertToDefault( "does_not_exist" ); + QVERIFY(!sc.isDirty()); + cg.writeEntry("Test", "Correct"); + QVERIFY(sc.isDirty()); + sc.sync(); + QVERIFY(!sc.isDirty()); + + cg.revertToDefault("Test"); + QVERIFY(sc.isDirty()); + QVERIFY(sc.sync()); + QVERIFY(!sc.isDirty()); + + cg.revertToDefault("Test"); + QVERIFY(!sc.isDirty()); +} + +void KConfigTest::testRevertAllEntries() +{ + // this tests the case were we revert (delete) all entries in a file, + // leaving a blank file + { + KConfig sc( "konfigtest2", KConfig::SimpleConfig ); + KConfigGroup cg( &sc, "Hello" ); + cg.writeEntry( "Test", "Correct" ); + } + + { + KConfig sc( "konfigtest2", KConfig::SimpleConfig ); + KConfigGroup cg( &sc, "Hello" ); + QCOMPARE( cg.readEntry( "Test", "Default" ), QString("Correct") ); + cg.revertToDefault( "Test" ); + } + + KConfig sc( "konfigtest2", KConfig::SimpleConfig ); + KConfigGroup cg( &sc, "Hello" ); + QCOMPARE( cg.readEntry( "Test", "Default" ), QString("Default") ); +} + +void KConfigTest::testSimple() +{ + // kdeglobals (which was created in initTestCase) must be found this way: + const QStringList kdeglobals = QStandardPaths::locateAll(QStandardPaths::GenericConfigLocation, QLatin1String("kdeglobals")); + QVERIFY(!kdeglobals.isEmpty()); + + KConfig sc2( "kconfigtest" ); + QCOMPARE(sc2.name(), QString("kconfigtest")); + + // make sure groupList() isn't returning something it shouldn't + Q_FOREACH(const QString& group, sc2.groupList()) { + QVERIFY(!group.isEmpty() && group != "<default>"); + QVERIFY(!group.contains(QChar(0x1d))); + } + + KConfigGroup sc3( &sc2, "AAA"); + + QVERIFY( sc3.hasKey( "stringEntry1" ) ); // from kdeglobals + QVERIFY( !sc3.isEntryImmutable("stringEntry1") ); + QCOMPARE( sc3.readEntry( "stringEntry1" ), QString( STRINGENTRY1 ) ); + + QVERIFY( !sc3.hasKey( "stringEntry2" ) ); + QCOMPARE( sc3.readEntry( "stringEntry2", QString("bla") ), QString( "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( "emptyEntry"/*, QString("Fietsbel")*/), QString("") ); + 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 ) ); + QVERIFY( !sc3.hasKey( "stringEntry5" ) ); + QCOMPARE( sc3.readEntry( "stringEntry5", QString("test") ), QString( "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( "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( "doubleEntry1", 0.0 ), DOUBLEENTRY ); + QCOMPARE( sc3.readEntry( "floatEntry1", 0.0f ), FLOATENTRY ); +} + +void KConfigTest::testDefaults() +{ + KConfig config("defaulttest", KConfig::NoGlobals); + const QString defaultsFile = "defaulttest.defaults"; + KConfig defaults(defaultsFile, KConfig::SimpleConfig); + + const QString Default("Default"); + const QString NotDefault("Not Default"); + const QString Value1(STRINGENTRY1); + const QString Value2(STRINGENTRY2); + + KConfigGroup group = defaults.group("any group"); + group.writeEntry("entry1", Default); + QVERIFY(group.sync()); + + group = config.group("any group"); + group.writeEntry("entry1", Value1); + group.writeEntry("entry2", Value2); + QVERIFY(group.sync()); + + config.addConfigSources(QStringList() << QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + '/' + defaultsFile); + + config.setReadDefaults(true); + QCOMPARE(group.readEntry("entry1", QString()), Default); + QCOMPARE(group.readEntry("entry2", NotDefault), NotDefault); // no default for entry2 + + config.setReadDefaults(false); + QCOMPARE(group.readEntry("entry1", Default), Value1); + QCOMPARE(group.readEntry("entry2", NotDefault), Value2); + + group.revertToDefault("entry1"); + QCOMPARE(group.readEntry("entry1", QString()), Default); + group.revertToDefault("entry2"); + QCOMPARE(group.readEntry("entry2", QString()), QString()); + + // TODO test reverting localized entries + + Q_ASSERT(config.isDirty()); + group.sync(); + + // Check that everything is OK on disk, too + KConfig reader("defaulttest", KConfig::NoGlobals); + reader.addConfigSources(QStringList() << QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + '/' + defaultsFile); + KConfigGroup readerGroup = reader.group("any group"); + QCOMPARE(readerGroup.readEntry("entry1", QString()), Default); + QCOMPARE(readerGroup.readEntry("entry2", QString()), QString()); +} + +void KConfigTest::testLocale() +{ + KConfig config("kconfigtest.locales", KConfig::SimpleConfig); + const QString Translated(TRANSLATEDSTRINGENTRY1); + const QString Untranslated(STRINGENTRY1); + + KConfigGroup group = config.group("Hello"); + group.writeEntry("stringEntry1", Untranslated); + config.setLocale("fr"); + group.writeEntry("stringEntry1", Translated, KConfig::Localized|KConfig::Persistent); + QVERIFY(config.sync()); + + QCOMPARE(group.readEntry("stringEntry1", QString()), Translated); + QCOMPARE(group.readEntryUntranslated("stringEntry1"), Untranslated); + + config.setLocale("C"); // strings written in the "C" locale are written as nonlocalized + group.writeEntry("stringEntry1", Untranslated, KConfig::Localized|KConfig::Persistent); + QVERIFY(config.sync()); + + QCOMPARE(group.readEntry("stringEntry1", QString()), Untranslated); +} + +void KConfigTest::testEncoding() +{ + QString groupstr = QString::fromUtf8("UTF-8:\xc3\xb6l"); + + KConfig c( "kconfigtestencodings" ); + KConfigGroup cg(&c, groupstr); + cg.writeEntry("key", "value"); + QVERIFY(c.sync()); + + QList<QByteArray> lines = readLines("kconfigtestencodings"); + QCOMPARE(lines.count(), 2); + QCOMPARE(lines.first(), QByteArray("[UTF-8:\xc3\xb6l]\n")); + + KConfig c2( "kconfigtestencodings" ); + KConfigGroup cg2(&c2, groupstr); + QVERIFY(cg2.readEntry("key") == QByteArray("value")); + + QVERIFY(c2.groupList().contains(groupstr)); +} + +void KConfigTest::testLists() +{ + KConfig sc2( "kconfigtest" ); + KConfigGroup sc3(&sc2, "List Types"); + + QCOMPARE( sc3.readEntry( QString("stringListEntry"), QStringList()), + STRINGLISTENTRY ); + + QCOMPARE( sc3.readEntry( QString("stringListEmptyEntry"), QStringList("wrong") ), + STRINGLISTEMPTYENTRY ); + + QCOMPARE( sc3.readEntry( QString("stringListJustEmptyElement"), QStringList() ), + STRINGLISTJUSTEMPTYELEMENT ); + + QCOMPARE( sc3.readEntry( QString("stringListEmptyTrailingElement"), QStringList() ), + STRINGLISTEMPTYTRAINLINGELEMENT ); + + QCOMPARE( sc3.readEntry( QString("stringListEscapeOddEntry"), QStringList()), + STRINGLISTESCAPEODDENTRY ); + + QCOMPARE( sc3.readEntry( QString("stringListEscapeEvenEntry"), QStringList()), + STRINGLISTESCAPEEVENENTRY ); + + QCOMPARE( sc3.readEntry( QString("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( sc3.readEntry( "listOfByteArraysEntry1", QList<QByteArray>()), BYTEARRAYLISTENTRY1 ); +} + +void KConfigTest::testPath() +{ + KConfig sc2( "kconfigtest" ); + KConfigGroup sc3(&sc2, "Path Type"); + QCOMPARE( sc3.readPathEntry( "homepath", QString() ), HOMEPATH ); + QCOMPARE( sc3.readPathEntry( "homepathescape", QString() ), HOMEPATHESCAPE ); + QCOMPARE( sc3.entryMap()["homepath"], HOMEPATH ); + + { + QFile file(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/pathtest"); + file.open(QIODevice::WriteOnly|QIODevice::Text); + QTextStream out(&file); + out.setCodec("UTF-8"); + out << "[Test Group]" << endl + << "homePath=$HOME/foo" << endl + << "homePath2=file://$HOME/foo" << endl + << "withBraces[$e]=file://${HOME}/foo" << endl + << "URL[$e]=file://${HOME}/foo" << endl + << "hostname[$e]=$(hostname)" << endl + << "noeol=foo"; // no EOL + } + KConfig cf2("pathtest"); + KConfigGroup group = cf2.group("Test Group"); + QVERIFY(group.hasKey("homePath")); + QCOMPARE(group.readPathEntry("homePath", QString()), HOMEPATH); + QVERIFY(group.hasKey("homePath2")); + QCOMPARE(group.readPathEntry("homePath2", QString()), QString("file://" + HOMEPATH) ); + QVERIFY(group.hasKey("withBraces")); + QCOMPARE(group.readPathEntry("withBraces", QString()), QString("file://" + HOMEPATH) ); + QVERIFY(group.hasKey("URL")); + QCOMPARE(group.readEntry("URL", QString()), QString("file://" + HOMEPATH) ); +#if !defined(Q_OS_WIN32) && !defined(Q_OS_MAC) + // I don't know if this will work on windows + // This test hangs on OS X + QVERIFY(group.hasKey("hostname")); + char hostname[256]; + QVERIFY(::gethostname(hostname, sizeof(hostname)) == 0); + QCOMPARE(group.readEntry("hostname", QString()), QString::fromLatin1(hostname)); +#endif + QVERIFY(group.hasKey("noeol")); + QCOMPARE(group.readEntry("noeol", QString()), QString("foo")); +} + +void KConfigTest::testPersistenceOfExpandFlagForPath() +{ + // This test checks that a path entry starting with $HOME is still flagged + // with the expand flag after the config was altered without rewriting the + // path entry. + + // 1st step: Open the config, add a new dummy entry and then sync the config + // back to the storage. + { + KConfig sc2( "kconfigtest" ); + KConfigGroup sc3(&sc2, "Path Type"); + sc3.writeEntry( "dummy", "dummy" ); + QVERIFY(sc2.sync()); + } + + // 2nd step: Call testPath() again. Rewriting the config must not break + // the testPath() test. + testPath(); +} + +void KConfigTest::testComplex() +{ + KConfig sc2( "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::ISODate), + DATETIMEENTRY.toString(Qt::ISODate) ); + QCOMPARE( sc3.readEntry( "dateEntry", QDate() ).toString(Qt::ISODate), + DATETIMEENTRY.date().toString(Qt::ISODate) ); + QCOMPARE( sc3.readEntry( "dateTimeEntry", QDate() ), DATETIMEENTRY.date() ); +} + +void KConfigTest::testEnums() +{ + KConfig sc("kconfigtest"); + KConfigGroup sc3(&sc, "Enum Types" ); + + QCOMPARE( sc3.readEntry( "enum-10" ), QString("Tens")); + QVERIFY( readEntry( sc3, "enum-100", Ones) != Ones); + QVERIFY( readEntry( sc3, "enum-100", Ones) != Tens); + + QCOMPARE( sc3.readEntry( "flags-bit0" ), QString("bit0")); + QVERIFY( readEntry( sc3, "flags-bit0", Flags() ) == bit0 ); + + int eid = staticMetaObject.indexOfEnumerator( "Flags" ); + QVERIFY( eid != -1 ); + QMetaEnum me = staticMetaObject.enumerator( eid ); + Flags bitfield = bit0|bit1; + + QCOMPARE( sc3.readEntry( "flags-bit0-bit1" ), QString( me.valueToKeys(bitfield) ) ); + QVERIFY( readEntry( sc3, "flags-bit0-bit1", Flags() ) == bitfield ); +} + +void KConfigTest::testEntryMap() +{ + KConfig sc("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)); + 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"), QString::number(DOUBLEENTRY, 'g', 15)); + QCOMPARE(entryMap.value("floatEntry1"), QString::number(FLOATENTRY, 'g', 8)); +} + +void KConfigTest::testInvalid() +{ + KConfig sc( "kconfigtest" ); + + // all of these should print a message to the kdebug.dbg file + KConfigGroup sc3(&sc, "Invalid Types" ); + sc3.writeEntry( "badList", VARIANTLISTENTRY2 ); + + QList<int> list; + + // 1 element list + list << 1; + sc3.writeEntry( QString("badList"), list); + + QVERIFY( sc3.readEntry( "badList", QPoint() ) == QPoint() ); + QVERIFY( sc3.readEntry( "badList", QRect() ) == QRect() ); + QVERIFY( sc3.readEntry( "badList", QSize() ) == QSize() ); + QVERIFY( sc3.readEntry( "badList", QDate() ) == QDate() ); + QVERIFY( sc3.readEntry( "badList", QDateTime() ) == QDateTime() ); + + // 2 element list + list << 2; + sc3.writeEntry( "badList", list); + + QVERIFY( sc3.readEntry( "badList", QRect() ) == QRect() ); + QVERIFY( sc3.readEntry( "badList", QDate() ) == QDate() ); + QVERIFY( sc3.readEntry( "badList", QDateTime() ) == QDateTime() ); + + // 3 element list + list << 303; + sc3.writeEntry( "badList", list); + + QVERIFY( sc3.readEntry( "badList", QPoint() ) == QPoint() ); + QVERIFY( sc3.readEntry( "badList", QRect() ) == QRect() ); + QVERIFY( sc3.readEntry( "badList", QSize() ) == QSize() ); + QVERIFY( sc3.readEntry( "badList", QDate() ) == QDate() ); // out of bounds + QVERIFY( sc3.readEntry( "badList", QDateTime() ) == QDateTime() ); + + // 4 element list + list << 4; + sc3.writeEntry( "badList", list ); + + QVERIFY( sc3.readEntry( "badList", QPoint() ) == QPoint() ); + QVERIFY( sc3.readEntry( "badList", QSize() ) == QSize() ); + QVERIFY( sc3.readEntry( "badList", QDate() ) == QDate() ); + QVERIFY( sc3.readEntry( "badList", QDateTime() ) == QDateTime() ); + + // 5 element list + list[2] = 3; + list << 5; + sc3.writeEntry( "badList", list); + + QVERIFY( sc3.readEntry( "badList", QPoint() ) == QPoint() ); + QVERIFY( sc3.readEntry( "badList", QRect() ) == QRect() ); + QVERIFY( sc3.readEntry( "badList", QSize() ) == QSize() ); + QVERIFY( sc3.readEntry( "badList", QDate() ) == QDate() ); + QVERIFY( sc3.readEntry( "badList", QDateTime() ) == QDateTime() ); + + // 6 element list + list << 6; + sc3.writeEntry( "badList", list); + + QVERIFY( sc3.readEntry( "badList", QPoint() ) == QPoint() ); + QVERIFY( sc3.readEntry( "badList", QRect() ) == QRect() ); + QVERIFY( sc3.readEntry( "badList", QSize() ) == QSize() ); +} + +void KConfigTest::testChangeGroup() +{ + KConfig sc( "kconfigtest" ); + KConfigGroup sc3(&sc, "Hello"); + QCOMPARE(sc3.name(), QString("Hello")); + KConfigGroup newGroup(sc3); +#ifndef KDE_NO_DEPRECATED + newGroup.changeGroup("FooBar"); // deprecated! + QCOMPARE(newGroup.name(), QString("FooBar")); + QCOMPARE(sc3.name(), QString("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()); +#endif + + KConfigGroup rootGroup(sc.group("")); + QCOMPARE(rootGroup.name(), QString("<default>")); + KConfigGroup sc32(rootGroup.group("Hello")); + QCOMPARE(sc32.name(), QString("Hello")); + KConfigGroup newGroup2(sc32); +#ifndef KDE_NO_DEPRECATED + newGroup2.changeGroup("FooBar"); // deprecated! + QCOMPARE(newGroup2.name(), QString("FooBar")); + QCOMPARE(sc32.name(), QString("Hello")); // unchanged +#endif +} + +// Simple test for deleteEntry +void KConfigTest::testDeleteEntry() +{ + const char* configFile = "kconfigdeletetest"; + { + KConfig conf(configFile); + conf.group("Hello").writeEntry("DelKey", "ToBeDeleted"); + } + const QList<QByteArray> lines = readLines(configFile); + Q_ASSERT(lines.contains("[Hello]\n")); + Q_ASSERT(lines.contains("DelKey=ToBeDeleted\n")); + + KConfig sc(configFile); + KConfigGroup group(&sc, "Hello"); + + group.deleteEntry("DelKey"); + QCOMPARE( group.readEntry("DelKey", QString("Fietsbel")), QString("Fietsbel") ); + + QVERIFY(group.sync()); + Q_ASSERT(!readLines(configFile).contains("DelKey=ToBeDeleted\n")); + QCOMPARE( group.readEntry("DelKey", QString("still deleted")), QString("still deleted") ); +} + +void KConfigTest::testDelete() +{ + KConfig sc( "kconfigtest" ); + + KConfigGroup ct(&sc, "Complex Types"); + + // First delete a nested group + KConfigGroup delgr(&ct, "Nested Group 3"); + QVERIFY(delgr.exists()); + QVERIFY(ct.hasGroup("Nested Group 3")); + delgr.deleteGroup(); + QVERIFY(!delgr.exists()); + QVERIFY(!ct.hasGroup("Nested Group 3")); + QVERIFY(ct.groupList().contains("Nested Group 3")); + + KConfigGroup ng(&ct, "Nested Group 2"); + QVERIFY(sc.hasGroup("Complex Types")); + QVERIFY(!sc.hasGroup("Does not exist")); + sc.deleteGroup("Complex Types"); + QCOMPARE(sc.group("Complex Types").keyList().count(), 0); + QVERIFY(!sc.hasGroup("Complex Types")); // #192266 + QVERIFY(!sc.group("Complex Types").exists()); + QVERIFY(!ct.hasGroup("Nested Group 1")); + + QCOMPARE(ct.group("Nested Group 1").keyList().count(), 0); + QCOMPARE(ct.group("Nested Group 2").keyList().count(), 0); + QCOMPARE(ng.group("Nested Group 2.1").keyList().count(), 0); + + 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(cg.sync()); + // Check what happens on disk + const QList<QByteArray> lines = readLines(); + //qDebug() << lines; + QVERIFY(!lines.contains("[Complex Types]\n")); + QVERIFY(!lines.contains("[Complex Types][Nested Group 1]\n")); + QVERIFY(!lines.contains("[Complex Types][Nested Group 2]\n")); + QVERIFY(!lines.contains("[Complex Types][Nested Group 2.1]\n")); + QVERIFY(!lines.contains("[AAA]\n")); + 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("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"); + QVERIFY(cf.sync()); + + int count=0; + Q_FOREACH(const QByteArray& item, readLines()) + if (item.startsWith("devices|")) // krazy:exclude=strings + count++; + QCOMPARE(count, 2); + cg.deleteEntry("devices|manual|/mnt/ipod"); + QVERIFY(cf.sync()); + Q_FOREACH(const QByteArray& item, readLines()) + QVERIFY(!item.contains("ipod")); +} + +void KConfigTest::testDefaultGroup() +{ + KConfig sc( "kconfigtest" ); + KConfigGroup defaultGroup(&sc, "<default>"); + QCOMPARE(defaultGroup.name(), QString("<default>")); + QVERIFY(!defaultGroup.exists()); + defaultGroup.writeEntry("TestKey", "defaultGroup"); + QVERIFY(defaultGroup.exists()); + QCOMPARE(defaultGroup.readEntry("TestKey", QString()), QString("defaultGroup")); + QVERIFY(sc.sync()); + + { + // Test reading it + KConfig sc2("kconfigtest"); + KConfigGroup defaultGroup2(&sc2, "<default>"); + QCOMPARE(defaultGroup2.name(), QString("<default>")); + QVERIFY(defaultGroup2.exists()); + QCOMPARE(defaultGroup2.readEntry("TestKey", QString()), QString("defaultGroup")); + } + { + // Test reading it + KConfig sc2("kconfigtest"); + KConfigGroup emptyGroup(&sc2, ""); + QCOMPARE(emptyGroup.name(), QString("<default>")); + QVERIFY(emptyGroup.exists()); + QCOMPARE(emptyGroup.readEntry("TestKey", QString()), QString("defaultGroup")); + } + + QList<QByteArray> lines = readLines(); + QVERIFY(!lines.contains("[]\n")); + QCOMPARE(lines.first(), QByteArray("TestKey=defaultGroup\n")); + + // Now that the group exists make sure it isn't returned from groupList() + Q_FOREACH(const QString& group, sc.groupList()) { + QVERIFY(!group.isEmpty() && group != "<default>"); + } + + defaultGroup.deleteGroup(); + QVERIFY(sc.sync()); + + // Test if deleteGroup worked + lines = readLines(); + QVERIFY(lines.first() != QByteArray("TestKey=defaultGroup\n")); +} + +void KConfigTest::testEmptyGroup() +{ + KConfig sc( "kconfigtest" ); + KConfigGroup emptyGroup(&sc, ""); + QCOMPARE(emptyGroup.name(), QString("<default>")); // confusing, heh? + QVERIFY(!emptyGroup.exists()); + emptyGroup.writeEntry("TestKey", "emptyGroup"); + QVERIFY(emptyGroup.exists()); + QCOMPARE(emptyGroup.readEntry("TestKey", QString()), QString("emptyGroup")); + QVERIFY(sc.sync()); + + { + // Test reading it + KConfig sc2("kconfigtest"); + KConfigGroup defaultGroup(&sc2, "<default>"); + QCOMPARE(defaultGroup.name(), QString("<default>")); + QVERIFY(defaultGroup.exists()); + QCOMPARE(defaultGroup.readEntry("TestKey", QString()), QString("emptyGroup")); + } + { + // Test reading it + KConfig sc2("kconfigtest"); + KConfigGroup emptyGroup2(&sc2, ""); + QCOMPARE(emptyGroup2.name(), QString("<default>")); + QVERIFY(emptyGroup2.exists()); + QCOMPARE(emptyGroup2.readEntry("TestKey", QString()), QString("emptyGroup")); + } + + QList<QByteArray> lines = readLines(); + QVERIFY(!lines.contains("[]\n")); // there's no support for the [] group, in fact. + QCOMPARE(lines.first(), QByteArray("TestKey=emptyGroup\n")); + + // Now that the group exists make sure it isn't returned from groupList() + Q_FOREACH(const QString& group, sc.groupList()) { + QVERIFY(!group.isEmpty() && group != "<default>"); + } + emptyGroup.deleteGroup(); + QVERIFY(sc.sync()); + + // Test if deleteGroup worked + lines = readLines(); + QVERIFY(lines.first() != QByteArray("TestKey=defaultGroup\n")); +} + +void KConfigTest::testCascadingWithLocale() +{ + // This test relies on XDG_CONFIG_DIRS, which only has effect on Unix. + // Cascading (more than two levels) isn't available at all on Windows. +#ifdef Q_OS_UNIX + QTemporaryDir middleDir; + QTemporaryDir globalDir; + qputenv("XDG_CONFIG_DIRS", qPrintable(middleDir.path() + QString(":") + globalDir.path())); + + const QString globalConfigDir = globalDir.path(); + QVERIFY(QDir().mkpath(globalConfigDir)); + QFile global(globalConfigDir + "/foo.desktop"); + QVERIFY(global.open(QIODevice::WriteOnly|QIODevice::Text)); + QTextStream globalOut(&global); + globalOut << "[Group]" << endl + << "FromGlobal=true" << endl + << "FromGlobal[fr]=vrai" << endl + << "Name=Testing" << endl + << "Name[fr]=FR" << endl + << "Other=Global" << endl + << "Other[fr]=Global_FR" << endl; + global.close(); + + const QString middleConfigDir = middleDir.path(); + QVERIFY(QDir().mkpath(middleConfigDir)); + QFile local(middleConfigDir + "/foo.desktop"); + QVERIFY(local.open(QIODevice::WriteOnly|QIODevice::Text)); + QTextStream out(&local); + out << "[Group]" << endl + << "FromLocal=true" << endl + << "FromLocal[fr]=vrai" << endl + << "Name=Local Testing" << endl + << "Name[fr]=FR" << endl + << "Other=English Only" << endl; + local.close(); + + KConfig config("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")); + config.setLocale("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 +#endif +} + +void KConfigTest::testMerge() +{ + KConfig config("mergetest", KConfig::SimpleConfig); + + KConfigGroup cg = config.group("some group"); + cg.writeEntry("entry", " random entry"); + cg.writeEntry("another entry", "blah blah blah"); + + { // simulate writing by another process + QFile file(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/mergetest"); + file.open(QIODevice::WriteOnly|QIODevice::Text); + QTextStream out(&file); + out.setCodec("UTF-8"); + out << "[Merged Group]" << endl + << "entry1=Testing" << endl + << "entry2=More Testing" << endl + << "[some group]" << endl + << "entry[fr]=French" << endl + << "entry[es]=Spanish" << endl + << "entry[de]=German" << endl; + } + QVERIFY(config.sync()); + + { + QList<QByteArray> lines; + // this is what the file should look like + lines << "[Merged Group]\n" + << "entry1=Testing\n" + << "entry2=More Testing\n" + << "\n" + << "[some group]\n" + << "another entry=blah blah blah\n" + << "entry=\\srandom entry\n" + << "entry[de]=German\n" + << "entry[es]=Spanish\n" + << "entry[fr]=French\n"; + QFile file(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/mergetest"); + file.open(QIODevice::ReadOnly|QIODevice::Text); + Q_FOREACH (const QByteArray& line, lines) { + QCOMPARE(line, file.readLine()); + } + } +} + +void KConfigTest::testImmutable() +{ + { + QFile file(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/immutabletest"); + file.open(QIODevice::WriteOnly|QIODevice::Text); + QTextStream out(&file); + out.setCodec("UTF-8"); + out << "[$i]" << endl + << "entry1=Testing" << endl + << "[group][$i]" << endl + << "[group][subgroup][$i]" << endl; + } + + KConfig config("immutabletest", KConfig::SimpleConfig); + QVERIFY(config.isGroupImmutable(QByteArray())); + KConfigGroup cg = config.group(QByteArray()); + QVERIFY(cg.isEntryImmutable("entry1")); + KConfigGroup cg1 = config.group("group"); + QVERIFY(cg1.isImmutable()); + KConfigGroup cg1a = cg.group("group"); + QVERIFY(cg1a.isImmutable()); + KConfigGroup cg2 = cg1.group("subgroup"); + QVERIFY(cg2.isImmutable()); +} + +void KConfigTest::testOptionOrder() +{ + { + QFile file(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/doubleattrtest"); + file.open(QIODevice::WriteOnly|QIODevice::Text); + QTextStream out(&file); + out.setCodec("UTF-8"); + out << "[group3]" << endl + << "entry2=unlocalized" << endl + << "entry2[$i][de_DE]=t2" << endl; + } + KConfig config("doubleattrtest", KConfig::SimpleConfig); + config.setLocale("de_DE"); + KConfigGroup cg3 = config.group("group3"); + QVERIFY(!cg3.isImmutable()); + QCOMPARE(cg3.readEntry("entry2",""), QString("t2")); + QVERIFY(cg3.isEntryImmutable("entry2")); + config.setLocale("C"); + QCOMPARE(cg3.readEntry("entry2",""), QString("unlocalized")); + QVERIFY(!cg3.isEntryImmutable("entry2")); + cg3.writeEntry("entry2","modified"); + QVERIFY(config.sync()); + + { + QList<QByteArray> lines; + // this is what the file should look like + lines << "[group3]\n" + << "entry2=modified\n" + << "entry2[de_DE][$i]=t2\n"; + + QFile file(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/doubleattrtest"); + file.open(QIODevice::ReadOnly|QIODevice::Text); + Q_FOREACH (const QByteArray& line, lines) { + QCOMPARE(line, file.readLine()); + } + } +} + + +void KConfigTest::testGroupEscape() +{ + KConfig config("groupescapetest", KConfig::SimpleConfig); + QVERIFY( config.group(DOLLARGROUP).exists() ); +} + +void KConfigTest::testSubGroup() +{ + KConfig sc( "kconfigtest" ); + KConfigGroup cg( &sc, "ParentGroup" ); + QCOMPARE(cg.readEntry( "parentgrpstring", ""), QString("somevalue") ); + KConfigGroup subcg1( &cg, "SubGroup1"); + QCOMPARE(subcg1.name(), QString("SubGroup1")); + QCOMPARE(subcg1.readEntry( "somestring", ""), QString("somevalue") ); + KConfigGroup subcg2( &cg, "SubGroup2"); + QCOMPARE(subcg2.name(), QString("SubGroup2")); + QCOMPARE(subcg2.readEntry( "substring", ""), QString("somevalue") ); + KConfigGroup subcg3( &cg, "SubGroup/3"); + QCOMPARE(subcg3.readEntry( "sub3string", ""), QString("somevalue") ); + QCOMPARE(subcg3.name(), QString("SubGroup/3")); + KConfigGroup rcg( &sc, "" ); + KConfigGroup srcg( &rcg, "ParentGroup" ); + QCOMPARE(srcg.readEntry( "parentgrpstring", ""), QString("somevalue") ); + + QStringList groupList = cg.groupList(); + groupList.sort(); // comes from QSet, so order is undefined + QCOMPARE(groupList, (QStringList() << "SubGroup/3" << "SubGroup1" << "SubGroup2")); + + const QStringList expectedSubgroup3Keys = (QStringList() << "sub3string"); + QCOMPARE(subcg3.keyList(), expectedSubgroup3Keys); + const QStringList expectedParentGroupKeys(QStringList() << "parentgrpstring"); + + QCOMPARE(cg.keyList(), expectedParentGroupKeys); + + QCOMPARE(QStringList(cg.entryMap().keys()), expectedParentGroupKeys); + QCOMPARE(QStringList(subcg3.entryMap().keys()), expectedSubgroup3Keys); + + // Create A group containing only other groups. We want to make sure it + // shows up in groupList of sc + KConfigGroup neg(&sc, "NoEntryGroup"); + KConfigGroup negsub1(&neg, "NEG Child1"); + negsub1.writeEntry( "entry", "somevalue" ); + KConfigGroup negsub2(&neg, "NEG Child2"); + KConfigGroup negsub3(&neg, "NEG Child3"); + KConfigGroup negsub31(&negsub3, "NEG Child3-1"); + KConfigGroup negsub4(&neg, "NEG Child4"); + KConfigGroup negsub41(&negsub4, "NEG Child4-1"); + negsub41.writeEntry( "entry", "somevalue" ); + + // A group exists if it has content + QVERIFY(negsub1.exists()); + + // But it doesn't exist if it has no content + // Ossi and David say: this is how it's supposed to work. + // However you could add a dummy entry for now, or we could add a "Persist" feature to kconfig groups + // which would make it written out, much like "immutable" already makes them persistent. + QVERIFY(!negsub2.exists()); + + // A subgroup does not qualify as content if it is also empty + QVERIFY(!negsub3.exists()); + + // A subgroup with content is ok + QVERIFY(negsub4.exists()); + + // Only subgroups with content show up in groupList() + //QEXPECT_FAIL("", "Empty subgroups do not show up in groupList()", Continue); + //QCOMPARE(neg.groupList(), QStringList() << "NEG Child1" << "NEG Child2" << "NEG Child3" << "NEG Child4"); + // 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"); + + // make sure groupList() isn't returning something it shouldn't + Q_FOREACH(const QString& group, sc.groupList()) { + QVERIFY(!group.isEmpty() && group != "<default>"); + QVERIFY(!group.contains(QChar(0x1d))); + QVERIFY(!group.contains("subgroup")); + QVERIFY(!group.contains("SubGroup")); + } + + QVERIFY(sc.sync()); + + // Check that the empty groups are not written out. + const QList<QByteArray> lines = readLines(); + QVERIFY(lines.contains("[NoEntryGroup][NEG Child1]\n")); + QVERIFY(!lines.contains("[NoEntryGroup][NEG Child2]\n")); + QVERIFY(!lines.contains("[NoEntryGroup][NEG Child3]\n")); + QVERIFY(!lines.contains("[NoEntryGroup][NEG Child4]\n")); // implicit group, not written out + QVERIFY(lines.contains("[NoEntryGroup][NEG Child4][NEG Child4-1]\n")); +} + +void KConfigTest::testAddConfigSources() +{ + KConfig cf("specificrc"); + + cf.addConfigSources(QStringList() << QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/baserc"); + cf.reparseConfiguration(); + + KConfigGroup specificgrp(&cf, "Specific Only Group"); + QCOMPARE(specificgrp.readEntry("ExistingEntry", ""), QString("DevValue")); + + KConfigGroup sharedgrp(&cf, "Shared Group"); + QCOMPARE(sharedgrp.readEntry("SomeSpecificOnlyEntry",""), QString("DevValue")); + QCOMPARE(sharedgrp.readEntry("SomeBaseOnlyEntry",""), QString("BaseValue")); + QCOMPARE(sharedgrp.readEntry("SomeSharedEntry",""), QString("DevValue")); + + KConfigGroup basegrp(&cf, "Base Only Group"); + QCOMPARE(basegrp.readEntry("ExistingEntry", ""), QString("BaseValue")); + basegrp.writeEntry("New Entry Base Only", "SomeValue"); + + KConfigGroup newgrp(&cf, "New Group"); + newgrp.writeEntry("New Entry", "SomeValue"); + + QVERIFY(cf.sync()); + + KConfig plaincfg("specificrc"); + + KConfigGroup newgrp2(&plaincfg, "New Group"); + QCOMPARE(newgrp2.readEntry("New Entry", ""), QString("SomeValue")); + + KConfigGroup basegrp2(&plaincfg, "Base Only Group"); + QCOMPARE(basegrp2.readEntry("New Entry Base Only", ""), QString("SomeValue")); +} + +void KConfigTest::testGroupCopyTo() +{ + KConfig cf1("kconfigtest"); + KConfigGroup original = cf1.group("Enum Types"); + + KConfigGroup copy = cf1.group("Enum Types Copy"); + original.copyTo(©); // copy from one group to another + QCOMPARE(copy.entryMap(), original.entryMap()); + + KConfig cf2("copy_of_kconfigtest", KConfig::SimpleConfig); + QVERIFY(!cf2.hasGroup(original.name())); + QVERIFY(!cf2.hasGroup(copy.name())); + + KConfigGroup newGroup = cf2.group(original.name()); + original.copyTo(&newGroup); // copy from one file to another + QVERIFY(cf2.hasGroup(original.name())); + QVERIFY(!cf2.hasGroup(copy.name())); // make sure we didn't copy more than we wanted + QCOMPARE(newGroup.entryMap(), original.entryMap()); +} + +void KConfigTest::testConfigCopyToSync() +{ + KConfig cf1("kconfigtest"); + // Prepare source file + KConfigGroup group(&cf1, "CopyToTest"); + group.writeEntry("Type", "Test"); + QVERIFY(cf1.sync()); + + // Copy to "destination" + const QString destination = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/kconfigcopytotest"; + QFile::remove(destination); + + KConfig cf2("kconfigcopytotest"); + KConfigGroup group2(&cf2, "CopyToTest"); + + group.copyTo(&group2); + + QString testVal = group2.readEntry("Type"); + QCOMPARE(testVal, QString("Test")); + // should write to disk the copied data from group + QVERIFY(cf2.sync()); + QVERIFY(QFile::exists(destination)); +} + +void KConfigTest::testConfigCopyTo() +{ + KConfig cf1("kconfigtest"); + { + // Prepare source file + KConfigGroup group(&cf1, "CopyToTest"); + group.writeEntry("Type", "Test"); + QVERIFY(cf1.sync()); + } + + { + // Copy to "destination" + const QString destination = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/kconfigcopytotest"; + QFile::remove(destination); + KConfig cf2; + cf1.copyTo(destination, &cf2); + KConfigGroup group2(&cf2, "CopyToTest"); + QString testVal = group2.readEntry("Type"); + QCOMPARE(testVal, QString("Test")); + QVERIFY(cf2.sync()); + QVERIFY(QFile::exists(destination)); + } + + // Check copied config file on disk + KConfig cf3("kconfigcopytotest"); + KConfigGroup group3(&cf3, "CopyToTest"); + QString testVal = group3.readEntry("Type"); + QCOMPARE(testVal, QString("Test")); +} + +void KConfigTest::testReparent() +{ + KConfig cf("kconfigtest"); + const QString name("Enum Types"); + KConfigGroup group = cf.group(name); + const QMap<QString, QString> originalMap = group.entryMap(); + KConfigGroup parent = cf.group("Parent Group"); + + QVERIFY(!parent.hasGroup(name)); + + QVERIFY(group.entryMap() == originalMap); + + group.reparent(&parent); // see if it can be made a sub-group of another group + QVERIFY(parent.hasGroup(name)); + QCOMPARE(group.entryMap(), originalMap); + + group.reparent(&cf); // see if it can make it a top-level group again +// QVERIFY(!parent.hasGroup(name)); + QCOMPARE(group.entryMap(), originalMap); +} + +static void ageTimeStamp(const QString& path, int nsec) +{ +#ifdef Q_OS_UNIX + QDateTime mtime = QFileInfo(path).lastModified().addSecs(-nsec); + struct utimbuf utbuf; + utbuf.actime = mtime.toTime_t(); + utbuf.modtime = utbuf.actime; + utime(QFile::encodeName(path), &utbuf); +#else + QTest::qSleep(nsec * 1000); +#endif +} + +void KConfigTest::testWriteOnSync() +{ + QDateTime oldStamp, newStamp; + KConfig sc("kconfigtest", KConfig::IncludeGlobals); + + // Age the timestamp of global config file a few sec, and collect it. + QString globFile = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/kdeglobals"; + ageTimeStamp(globFile, 2); // age 2 sec + oldStamp = QFileInfo(globFile).lastModified(); + + // Add a local entry and sync the config. + // Should not rewrite the global config file. + KConfigGroup cgLocal(&sc, "Locals"); + cgLocal.writeEntry("someLocalString", "whatever"); + QVERIFY(sc.sync()); + + // Verify that the timestamp of global config file didn't change. + newStamp = QFileInfo(globFile).lastModified(); + QCOMPARE(newStamp, oldStamp); + + // Age the timestamp of local config file a few sec, and collect it. + QString locFile = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/kconfigtest"; + ageTimeStamp(locFile, 2); // age 2 sec + oldStamp = QFileInfo(locFile).lastModified(); + + // Add a global entry and sync the config. + // Should not rewrite the local config file. + KConfigGroup cgGlobal(&sc, "Globals"); + cgGlobal.writeEntry("someGlobalString", "whatever", + KConfig::Persistent|KConfig::Global); + QVERIFY(sc.sync()); + + // Verify that the timestamp of local config file didn't change. + newStamp = QFileInfo(locFile).lastModified(); + QCOMPARE(newStamp, oldStamp); +} + +void KConfigTest::testFailOnReadOnlyFileSync() +{ + KConfig sc("kconfigfailonreadonlytest"); + KConfigGroup cgLocal(&sc, "Locals"); + + cgLocal.writeEntry("someLocalString", "whatever"); + QVERIFY(cgLocal.sync()); + + QFile f(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + '/' + sc.name()); + QVERIFY(f.exists()); + QVERIFY(f.setPermissions(QFileDevice::ReadOwner)); + + cgLocal.writeEntry("someLocalString", "whatever2"); + QVERIFY(!cgLocal.sync()); + + QVERIFY(f.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner)); + QVERIFY(f.remove()); +} + +void KConfigTest::testDirtyOnEqual() +{ + QDateTime oldStamp, newStamp; + KConfig sc("kconfigtest"); + + // Initialize value + KConfigGroup cgLocal(&sc, "random"); + cgLocal.writeEntry("theKey", "whatever"); + QVERIFY(sc.sync()); + + // Age the timestamp of local config file a few sec, and collect it. + QString locFile = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/kconfigtest"; + ageTimeStamp(locFile, 2); // age 2 sec + oldStamp = QFileInfo(locFile).lastModified(); + + // Write exactly the same again + cgLocal.writeEntry("theKey", "whatever"); + // This should be a no-op + QVERIFY(sc.sync()); + + // Verify that the timestamp of local config file didn't change. + newStamp = QFileInfo(locFile).lastModified(); + QCOMPARE(newStamp, oldStamp); +} + +void KConfigTest::testDirtyOnEqualOverdo() +{ + QByteArray val1("\0""one", 4); + QByteArray val2("\0""two", 4); + QByteArray defvalr; + + KConfig sc("kconfigtest"); + KConfigGroup cgLocal(&sc, "random"); + cgLocal.writeEntry("someKey", val1); + QCOMPARE(cgLocal.readEntry("someKey", defvalr), val1); + cgLocal.writeEntry("someKey", val2); + QCOMPARE(cgLocal.readEntry("someKey", defvalr), val2); +} + + +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"; + QFile::remove(file); + QDir().rmdir(subdir); + QVERIFY(!QDir().exists(subdir)); + KDesktopFile desktopFile(file); + desktopFile.desktopGroup().writeEntry("key", "value"); + QVERIFY(desktopFile.sync()); + QVERIFY(QFile::exists(file)); + + // Cleanup + QFile::remove(file); + QDir().rmdir(subdir); +} + +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(), "syncOnExit"); + grp.writeEntry("key", "value"); +} + +void KConfigTest::testSharedConfig() +{ + // Can I use a KConfigGroup even after the KSharedConfigPtr goes out of scope? + KConfigGroup myConfigGroup; + { + KSharedConfigPtr config = KSharedConfig::openConfig("kconfigtest"); + myConfigGroup = KConfigGroup(config, "Hello"); + } + QCOMPARE(myConfigGroup.readEntry("stringEntry1"), QString(STRINGENTRY1)); +} + +void KConfigTest::testLocaleConfig() +{ + // Initialize the testdata + QDir dir; + QString subdir = QDir::home().canonicalPath() + "/.kde-unit-test/"; + dir.mkpath(subdir); + QString file = subdir + "/localized.test"; + QFile::remove(file); + QFile f(file); + QVERIFY(f.open(QIODevice::WriteOnly)); + QTextStream ts(&f); + ts << "[Test_Wrong]\n"; + ts << "foo[ca]=5\n"; + ts << "foostring[ca]=nice\n"; + ts << "foobool[ca]=true\n"; + ts << "[Test_Right]\n"; + ts << "foo=5\n"; + ts << "foo[ca]=5\n"; + ts << "foostring=primary\n"; + ts << "foostring[ca]=nice\n"; + ts << "foobool=primary\n"; + ts << "foobool[ca]=true\n"; + f.close(); + + // Load the testdata + QVERIFY(QFile::exists(file)); + KConfig config(file); + config.setLocale("ca"); + + // This group has only localized values. That is not supported. The values + // should be dropped on loading. + KConfigGroup cg(&config, "Test_Wrong"); + QEXPECT_FAIL("", "The localized values are not dropped", Continue); + QVERIFY(!cg.hasKey("foo")); + QEXPECT_FAIL("", "The localized values are not dropped", Continue); + QVERIFY(!cg.hasKey("foostring")); + QEXPECT_FAIL("", "The localized values are not dropped", Continue); + QVERIFY(!cg.hasKey("foobool")); + + // Now check the correct config group + KConfigGroup cg2(&config, "Test_Right"); + QCOMPARE(cg2.readEntry("foo"), QString("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("foobool", false), true); + + // Clean up after the testcase + QFile::remove(file); +} + + +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"; + QFile::remove(file); + QFile f(file); + QVERIFY(f.open(QIODevice::WriteOnly)); + QTextStream ts(&f); + ts << "[Test4711]\n"; + ts << "foo=3\n"; + ts << "foo[ca]=5\n"; + ts << "foo[de]=7\n"; + ts << "foostring=ugly\n"; + ts << "foostring[ca]=nice\n"; + ts << "foostring[de]=schoen\n"; + ts << "foobool=false\n"; + ts << "foobool[ca]=true\n"; + ts << "foobool[de]=true\n"; + f.close(); + + // Load the testdata. We start in locale "ca". + QVERIFY(QFile::exists(file)); + KConfig config(file); + config.setLocale("ca"); + KConfigGroup cg(&config, "Test4711"); + + // Delete a value. Once with localized, once with Normal + cg.deleteEntry("foostring", KConfigBase::Persistent | KConfigBase::Localized); + cg.deleteEntry("foobool"); + QVERIFY(config.sync()); + + // The value is now gone. The others are still there. Everything correct + // here. + QVERIFY(!cg.hasKey("foostring")); + QVERIFY(!cg.hasKey("foobool")); + QVERIFY(cg.hasKey("foo")); + + // The current state is: (Just return before this comment.) + // [...] + // foobool[ca]=true + // foobool[de]=wahr + // foostring=ugly + // foostring[de]=schoen + + // Now switch the locale to "de" and repeat the checks. Results should be + // the same. But they currently are not. The localized value are + // independent of each other. All values are still there in "de". + config.setLocale("de"); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foostring")); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foobool")); + QVERIFY(cg.hasKey("foo")); + // Check where the wrong values come from. + // We get the "de" value. + QCOMPARE(cg.readEntry("foostring", "nothing"), QString("schoen")); + // We get the "de" value. + QCOMPARE(cg.readEntry("foobool", false), true); + + // Now switch the locale back "ca" and repeat the checks. Results are + // again different. + config.setLocale("ca"); + // This line worked above. But now it fails. + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foostring")); + // This line worked above too. + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foobool")); + 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")); + // We get the "ca" value. + QCOMPARE(cg.readEntry("foobool", false), true); + + // Now test the deletion of a group. + cg.deleteGroup(); + QVERIFY(config.sync()); + + // Current state: [ca] and [de] entries left... oops. + //qDebug() << readLinesFrom(file); + + // Bug: The group still exists [because of the localized entries]... + QVERIFY(cg.exists()); + QVERIFY(!cg.hasKey("foo")); + QVERIFY(!cg.hasKey("foostring")); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foobool")); + + // Now switch the locale to "de" and repeat the checks. All values + // still here because only the primary values are deleted. + config.setLocale("de"); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foo")); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foostring")); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foobool")); + // Check where the wrong values come from. + // We get the "de" value. + QCOMPARE(cg.readEntry("foostring", "nothing"), QString("schoen")); + // We get the "de" value. + QCOMPARE(cg.readEntry("foobool", false), true); + // We get the "de" value. + QCOMPARE(cg.readEntry("foo", 0), 7); + + // Now switch the locale to "ca" and repeat the checks + // "foostring" is now really gone because both the primary value and the + // "ca" value are deleted. + config.setLocale("ca"); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foo")); + QVERIFY(!cg.hasKey("foostring")); + QEXPECT_FAIL("", "Currently localized values are not deleted correctly", Continue); + QVERIFY(!cg.hasKey("foobool")); + // Check where the wrong values come from. + // We get the "ca" value. + QCOMPARE(cg.readEntry("foobool", false), true); + // We get the "ca" value. + QCOMPARE(cg.readEntry("foo", 0), 5); + + // Cleanup + QFile::remove(file); +} + + +void KConfigTest::testKdeGlobals() +{ + { + KConfig glob("kdeglobals"); + KConfigGroup general(&glob, "General"); + general.writeEntry("testKG", "1"); + QVERIFY(glob.sync()); + } + + KConfig globRead("kdeglobals"); + const KConfigGroup general(&globRead, "General"); + QCOMPARE(general.readEntry("testKG"), QString("1")); + + // Check we wrote into kdeglobals + const QList<QByteArray> lines = readLines("kdeglobals"); + QVERIFY(lines.contains("[General]\n")); + QVERIFY(lines.contains("testKG=1\n")); + + // Writing using NoGlobals + { + KConfig glob("kdeglobals", KConfig::NoGlobals); + KConfigGroup general(&glob, "General"); + general.writeEntry("testKG", "2"); + QVERIFY(glob.sync()); + } + globRead.reparseConfiguration(); + QCOMPARE(general.readEntry("testKG"), QString("2")); + + // Reading using NoGlobals + { + KConfig globReadNoGlob("kdeglobals", KConfig::NoGlobals); + const KConfigGroup generalNoGlob(&globReadNoGlob, "General"); + QCOMPARE(generalNoGlob.readEntry("testKG"), QString("2")); + } + + // TODO now use kconfigtest and writeEntry(,Global) -> should go into kdeglobals +} + +void KConfigTest::testAnonymousConfig() +{ + KConfig anonConfig(QString(), KConfig::SimpleConfig); + KConfigGroup general(&anonConfig, "General"); + QCOMPARE(general.readEntry("testKG"), QString()); // no kdeglobals merging + general.writeEntry("Foo", "Bar"); + QCOMPARE(general.readEntry("Foo"), QString("Bar")); +} + +#include <QThreadPool> +#include <qtconcurrentrun.h> + +// To find multithreading bugs: valgrind --tool=helgrind --track-lockorders=no ./kconfigtest testThreads +void KConfigTest::testThreads() +{ + QThreadPool::globalInstance()->setMaxThreadCount(6); + QList<QFuture<void> > futures; + // Run in parallel some tests that work on different config files, + // otherwise unexpected things might indeed happen. + futures << QtConcurrent::run(this, &KConfigTest::testAddConfigSources); + futures << QtConcurrent::run(this, &KConfigTest::testSimple); + futures << QtConcurrent::run(this, &KConfigTest::testDefaults); + // QEXPECT_FAIL triggers race conditions, it should be fixed to use QThreadStorage... + //futures << QtConcurrent::run(this, &KConfigTest::testDeleteWhenLocalized); + //futures << QtConcurrent::run(this, &KConfigTest::testEntryMap); + Q_FOREACH(QFuture<void> f, futures) // krazy:exclude=foreach + f.waitForFinished(); +} |