1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <qdebug.h>

    44 #include <QtTest/QtTest>

    45 

    46 #include <QtCore/QSettings>

    47 #include <private/qsettings_p.h>

    48 //#include <QtGui/QApplication>

    49 #include <QtCore/QCoreApplication>

    50 #include <QtCore/QtGlobal>

    51 #include <QtCore/QMetaType>

    52 #include <QtCore/QtDebug>

    53 #include <QtCore/QString>

    54 

    55 #if !defined(Q_OS_SYMBIAN)

    56 # include <cctype>

    57 #endif

    58 #if defined(Q_OS_WIN) && defined(Q_CC_GNU)

    59 // need for unlink on mingw

    60 #include <io.h>

    61 #endif

    62 

    63 #ifndef QSETTINGS_P_H_VERSION

    64 #define QSETTINGS_P_H_VERSION 1

    65 #endif

    66 

    67 //TESTED_FILES=

    68 

    69 QT_FORWARD_DECLARE_CLASS(QSettings)

    70 QT_FORWARD_DECLARE_CLASS(QSettings)

    71 

    72 class tst_QSettings : public QObject

    73 {

    74     Q_OBJECT

    75 

    76 public:

    77     tst_QSettings();

    78 

    79 public slots:

    80     void init();

    81     void cleanup();

    82 private slots:

    83     void getSetCheck();

    84     void ctor_data();

    85     void ctor();

    86     void beginGroup();

    87     void setValue();

    88     void remove();

    89     void contains();

    90     void sync();

    91     void setFallbacksEnabled();

    92     void setFallbacksEnabled_data();

    93     void fromFile_data();

    94     void fromFile();

    95     void setIniCodec();

    96     void testArrays_data();

    97     void testArrays();

    98     void testEscapes();

    99     void testCompatFunctions();

   100     void testCaseSensitivity_data();

   101     void testCaseSensitivity();

   102     void testErrorHandling_data();

   103     void testErrorHandling();

   104     void testIniParsing_data();

   105     void testIniParsing();

   106     void testChildKeysAndGroups_data();

   107     void testChildKeysAndGroups();

   108     void testUpdateRequestEvent();

   109     void testThreadSafety();

   110     void testNormalizedKey_data();

   111     void testNormalizedKey();

   112     void testEmptyData();

   113     void testResourceFiles();

   114     void fileName();

   115     void isWritable_data();

   116     void isWritable();

   117     void childGroups_data();

   118     void childGroups();

   119     void childKeys_data();

   120     void childKeys();

   121     void allKeys_data();

   122     void allKeys();

   123     void registerFormat();

   124     void setPath();

   125     void setDefaultFormat();

   126     void dontCreateNeedlessPaths();

   127 #if !defined(Q_OS_WIN) && !defined(Q_OS_SYMBIAN)

   128     void dontReorderIniKeysNeedlessly();

   129 #endif

   130 

   131     /*

   132         These tests were developed for the Qt 3 QSettings class.

   133     */

   134 #ifdef QT3_SUPPORT

   135     void oldWriteEntryIni_data();

   136     void oldWriteEntryIni();

   137     void oldReadEntryIni_data();

   138     void oldReadEntryIni();

   139     void oldBeginGroup_data();

   140     void oldBeginGroup();

   141     void oldEndGroup_data();

   142     void oldEndGroup();

   143     void oldResetGroup_data();

   144     void oldResetGroup();

   145     void oldEntryList_data();

   146     void oldEntryList();

   147     void oldWriteEntry_QString_bool_data();

   148     void oldWriteEntry_QString_bool();

   149     void oldWriteEntry_QString_double_data();

   150     void oldWriteEntry_QString_double();

   151     void oldWriteEntry_QString_int_data();

   152     void oldWriteEntry_QString_int();

   153     void oldWriteEntry_QString_QString_data();

   154     void oldWriteEntry_QString_QString();

   155     void oldWriteEntry_QString_QStringList_data();

   156     void oldWriteEntry_QString_QStringList();

   157     void oldWriteEntry_QString_QStringList_QChar_data();

   158     void oldWriteEntry_QString_QStringList_QChar();

   159     void oldReadListEntry_QString();

   160     void oldReadListEntry_QString_QChar();

   161     void oldReadEntry();

   162     void oldReadNumEntry();

   163     void oldReadDoubleEntry();

   164     void oldReadBoolEntry();

   165     void oldGlobalVersusLocal();

   166     void oldRemoveEntry();

   167 #endif

   168 

   169     void testVariantTypes_data();

   170     void testVariantTypes();

   171     void rainersSyncBugOnMac_data();

   172     void rainersSyncBugOnMac();

   173     void recursionBug();

   174 #ifdef QT3_SUPPORT

   175     void setPathBug();

   176 #endif

   177 

   178     void testByteArray_data();

   179     void testByteArray();

   180 

   181 private:

   182     void oldWriteEntry_data();

   183     void oldReadEntry_data();

   184     void oldWriteEntryHelper(QSettings &settings);

   185     void oldReadEntryHelper(QSettings &settings);

   186 };

   187 

   188 // Testing get/set functions

   189 void tst_QSettings::getSetCheck()

   190 {

   191     QSettings obj1;

   192     // bool QSettings::fallbacksEnabled()

   193     // void QSettings::setFallbacksEnabled(bool)

   194     obj1.setFallbacksEnabled(false);

   195     QCOMPARE(false, obj1.fallbacksEnabled());

   196     obj1.setFallbacksEnabled(true);

   197     QCOMPARE(true, obj1.fallbacksEnabled());

   198 }

   199 

   200 //using namespace std;

   201 

   202 //#include <qapplication.h>

   203 #include <qcoreapplication.h>

   204 #include <qdir.h>

   205 #include <qregexp.h>

   206 #include <qthread.h>

   207 #include <stdlib.h>

   208 #ifndef Q_OS_WIN

   209 #include <unistd.h>

   210 #endif

   211 

   212 Q_DECLARE_METATYPE(QSettings::Format)

   213 

   214 #if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)

   215 static void removePath(const QString& _path)

   216 {

   217     QString path = _path;

   218     QDir dir(path);

   219     if (!dir.exists())

   220         return;

   221     QStringList entries = dir.entryList();

   222     foreach(QString name, entries) {

   223         QString absolute = path + name;

   224         if (QFileInfo(absolute).isDir())

   225             removePath(absolute+"\\");

   226         else

   227             QFile::remove(absolute);

   228     }

   229     dir.cdUp();

   230     if (path[path.size()-1] == '\\')

   231         path = path.left(path.size()-1);

   232     dir.rmdir(path.mid(path.lastIndexOf('\\')+1));

   233 }

   234 #endif

   235 

   236 static QString settingsPath(const char *path = "")

   237 {

   238     // Temporary path for files that are specified explictly in the constructor.

   239     QString tempPath = QDir::tempPath();

   240     if (tempPath.endsWith("/"))

   241 	tempPath.truncate(tempPath.size() - 1);

   242     return QDir::toNativeSeparators(tempPath + "/tst_QSettings/" + QLatin1String(path));

   243 }

   244 

   245 static bool readCustom1File(QIODevice &device, QSettings::SettingsMap &map)

   246 {

   247     QDataStream in(&device);

   248     quint32 magic;

   249     in >> magic;

   250     in >> map;

   251     return (magic == 0x01010101 && in.status() == QDataStream::Ok);

   252 }

   253 

   254 static bool writeCustom1File(QIODevice &device, const QSettings::SettingsMap &map)

   255 {

   256     QDataStream out(&device);

   257     out << quint32(0x01010101);

   258     out << map;

   259     return out.status() == QDataStream::Ok;

   260 }

   261 

   262 static bool readCustom2File(QIODevice &device, QSettings::SettingsMap &map)

   263 {

   264     QDataStream in(&device);

   265     quint64 magic;

   266     in >> magic;

   267     in >> map;

   268     return (magic == Q_UINT64_C(0x0202020202020202) && in.status() == QDataStream::Ok);

   269 }

   270 

   271 static bool writeCustom2File(QIODevice &device, const QSettings::SettingsMap &map)

   272 {

   273     QDataStream out(&device);

   274     out << Q_UINT64_C(0x0202020202020202);

   275     out << map;

   276     return out.status() == QDataStream::Ok;

   277 }

   278 

   279 static bool readCustom3File(QIODevice &device, QSettings::SettingsMap &map)

   280 {

   281     QTextStream in(&device);

   282     QString tag;

   283     in >> tag;

   284     if (tag == "OK") {

   285         map.insert("retval", "OK");

   286         return true;

   287     } else {

   288         return false;

   289     }

   290 }

   291 

   292 static bool writeCustom3File(QIODevice &device, const QSettings::SettingsMap &map)

   293 {

   294     QTextStream out(&device);

   295     if (map.value("retval") != "OK")

   296         return false;

   297 

   298     out << "OK";

   299     return true;

   300 }

   301 

   302 static void populateWithFormats()

   303 {

   304     QTest::addColumn<QSettings::Format>("format");

   305 

   306     QTest::newRow("native") << QSettings::NativeFormat;

   307     QTest::newRow("ini") << QSettings::IniFormat;

   308     QTest::newRow("custom1") << QSettings::CustomFormat1;

   309     QTest::newRow("custom2") << QSettings::CustomFormat2;

   310 }

   311 

   312 tst_QSettings::tst_QSettings()

   313 {

   314     QSettings::Format custom1 = QSettings::registerFormat("custom1", readCustom1File, writeCustom1File);

   315     QSettings::Format custom2 = QSettings::registerFormat("custom2", readCustom2File, writeCustom2File

   316 #ifndef QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER

   317                                                           , Qt::CaseInsensitive

   318 #endif

   319                                                           );

   320     QVERIFY(custom1 == QSettings::CustomFormat1);

   321     QVERIFY(custom2 == QSettings::CustomFormat2);

   322 }

   323 

   324 void tst_QSettings::init()

   325 {

   326     QSettings::setSystemIniPath(settingsPath("__system__"));

   327     QSettings::setUserIniPath(settingsPath("__user__"));

   328 

   329 #if defined(Q_OS_WIN)

   330     QSettings("HKEY_CURRENT_USER\\Software\\software.org", QSettings::NativeFormat).clear();

   331     QSettings("HKEY_LOCAL_MACHINE\\Software\\software.org", QSettings::NativeFormat).clear();

   332     QSettings("HKEY_CURRENT_USER\\Software\\other.software.org", QSettings::NativeFormat).clear();

   333     QSettings("HKEY_LOCAL_MACHINE\\Software\\other.software.org", QSettings::NativeFormat).clear();

   334     QSettings("HKEY_CURRENT_USER\\Software\\foo", QSettings::NativeFormat).clear();

   335     QSettings("HKEY_CURRENT_USER\\Software\\bar", QSettings::NativeFormat).clear();

   336     QSettings("HKEY_CURRENT_USER\\Software\\bat", QSettings::NativeFormat).clear();

   337     QSettings("HKEY_CURRENT_USER\\Software\\baz", QSettings::NativeFormat).clear();

   338     QSettings("HKEY_LOCAL_MACHINE\\Software\\foo", QSettings::NativeFormat).clear();

   339     QSettings("HKEY_LOCAL_MACHINE\\Software\\bar", QSettings::NativeFormat).clear();

   340     QSettings("HKEY_LOCAL_MACHINE\\Software\\bat", QSettings::NativeFormat).clear();

   341     QSettings("HKEY_LOCAL_MACHINE\\Software\\baz", QSettings::NativeFormat).clear();

   342     if (QDir(settingsPath()).exists()) {

   343 #if defined(Q_OS_WINCE)

   344         removePath(settingsPath());

   345 #else

   346         if (QSysInfo::windowsVersion() & QSysInfo::WV_NT_based)

   347 	    system(QString("rmdir /Q /S %1").arg(settingsPath()).toLatin1());

   348 	else

   349 	    system(QString("deltree /Y %1").arg(settingsPath()).toLatin1());

   350 #endif

   351     }

   352 #elif defined(Q_OS_DARWIN)

   353     QSettings(QSettings::UserScope, "software.org", "KillerAPP").clear();

   354     QSettings(QSettings::SystemScope, "software.org", "KillerAPP").clear();

   355     QSettings(QSettings::UserScope, "other.software.org", "KillerAPP").clear();

   356     QSettings(QSettings::SystemScope, "other.software.org", "KillerAPP").clear();

   357     QSettings(QSettings::UserScope, "software.org").clear();

   358     QSettings(QSettings::SystemScope, "software.org").clear();

   359     QSettings(QSettings::UserScope, "other.software.org").clear();

   360     QSettings(QSettings::SystemScope, "other.software.org").clear();

   361 #elif defined(Q_OS_SYMBIAN)

   362     removePath(settingsPath());

   363 #endif

   364 

   365 #if !defined(Q_OS_WIN) && !defined(Q_OS_SYMBIAN)

   366     system(QString("chmod -R u+rw %1 2> /dev/null").arg(settingsPath()).toLatin1());

   367     system(QString("rm -fr %1 2> /dev/null").arg(settingsPath()).toLatin1());

   368 #endif

   369 

   370     QFile::remove("foo");

   371 }

   372 

   373 void tst_QSettings::cleanup()

   374 {

   375     init();

   376 }

   377 

   378 /*

   379     Test the constructors and the assignment operator.

   380 */

   381 

   382 void tst_QSettings::ctor_data()

   383 {

   384     populateWithFormats();

   385 }

   386 

   387 void tst_QSettings::ctor()

   388 {

   389     QFETCH(QSettings::Format, format);

   390 

   391     {

   392         QSettings settings1(format, QSettings::UserScope, "software.org", "KillerAPP");

   393         QSettings settings2(format, QSettings::UserScope, "software.org");

   394         QSettings settings3(format, QSettings::SystemScope, "software.org", "KillerAPP");

   395         QSettings settings4(format, QSettings::SystemScope, "software.org");

   396 

   397         QSettings settings5(format, QSettings::UserScope, "software.org", "KillerAPP");

   398         QSettings settings6(format, QSettings::UserScope, "software.org");

   399         QSettings settings7(format, QSettings::SystemScope, "software.org", "KillerAPP");

   400         QSettings settings8(format, QSettings::SystemScope, "software.org");

   401 

   402         // test QSettings::format() while we're at it

   403         QVERIFY(settings1.format() == format);

   404         QVERIFY(settings2.format() == format);

   405         QVERIFY(settings3.format() == format);

   406         QVERIFY(settings4.format() == format);

   407 

   408         // test QSettings::scope() while we're at it

   409         QVERIFY(settings1.scope() == QSettings::UserScope);

   410         QVERIFY(settings2.scope() == QSettings::UserScope);

   411         QVERIFY(settings3.scope() == QSettings::SystemScope);

   412         QVERIFY(settings4.scope() == QSettings::SystemScope);

   413 

   414         // test QSettings::organizationName() while we're at it

   415         QVERIFY(settings1.organizationName() == "software.org");

   416         QVERIFY(settings2.organizationName() == "software.org");

   417         QVERIFY(settings3.organizationName() == "software.org");

   418         QVERIFY(settings4.organizationName() == "software.org");

   419 

   420         // test QSettings::applicationName() while we're at it

   421         QCOMPARE(settings1.applicationName(), QString("KillerAPP"));

   422         QVERIFY(settings2.applicationName().isEmpty());

   423         QVERIFY(settings3.applicationName() == "KillerAPP");

   424         QVERIFY(settings4.applicationName().isEmpty());

   425 

   426         /*

   427             Go forwards.

   428         */

   429         settings4.setValue("key 1", QString("doodah"));

   430 

   431         QCOMPARE(settings1.value("key 1").toString(), QString("doodah"));

   432         QCOMPARE(settings2.value("key 1").toString(), QString("doodah"));

   433         QCOMPARE(settings3.value("key 1").toString(), QString("doodah"));

   434         QCOMPARE(settings4.value("key 1").toString(), QString("doodah"));

   435 

   436         settings3.setValue("key 1", QString("blah"));

   437         QCOMPARE(settings1.value("key 1").toString(), QString("blah"));

   438         QCOMPARE(settings2.value("key 1").toString(), QString("doodah"));

   439         QCOMPARE(settings3.value("key 1").toString(), QString("blah"));

   440         QCOMPARE(settings4.value("key 1").toString(), QString("doodah"));

   441 

   442         settings2.setValue("key 1", QString("whoa"));

   443         QCOMPARE(settings1.value("key 1").toString(), QString("whoa"));

   444         QCOMPARE(settings2.value("key 1").toString(), QString("whoa"));

   445         QCOMPARE(settings3.value("key 1").toString(), QString("blah"));

   446         QCOMPARE(settings4.value("key 1").toString(), QString("doodah"));

   447 

   448         settings1.setValue("key 1", QString("gurgle"));

   449         QCOMPARE(settings1.value("key 1").toString(), QString("gurgle"));

   450         QCOMPARE(settings2.value("key 1").toString(), QString("whoa"));

   451         QCOMPARE(settings3.value("key 1").toString(), QString("blah"));

   452         QCOMPARE(settings4.value("key 1").toString(), QString("doodah"));

   453 

   454         /*

   455             Test the copies.

   456         */

   457         QCOMPARE(settings5.value("key 1").toString(), settings1.value("key 1").toString());

   458         QCOMPARE(settings6.value("key 1").toString(), settings2.value("key 1").toString());

   459         QCOMPARE(settings7.value("key 1").toString(), settings3.value("key 1").toString());

   460         QCOMPARE(settings8.value("key 1").toString(), settings4.value("key 1").toString());

   461 

   462         /*

   463             Go backwards.

   464         */

   465 

   466         settings2.setValue("key 1", QString("bilboh"));

   467         QCOMPARE(settings1.value("key 1").toString(), QString("gurgle"));

   468         QCOMPARE(settings2.value("key 1").toString(), QString("bilboh"));

   469         QCOMPARE(settings3.value("key 1").toString(), QString("blah"));

   470         QCOMPARE(settings4.value("key 1").toString(), QString("doodah"));

   471 

   472         settings3.setValue("key 1", QString("catha"));

   473         QCOMPARE(settings1.value("key 1").toString(), QString("gurgle"));

   474         QCOMPARE(settings2.value("key 1").toString(), QString("bilboh"));

   475         QCOMPARE(settings3.value("key 1").toString(), QString("catha"));

   476         QCOMPARE(settings4.value("key 1").toString(), QString("doodah"));

   477 

   478         settings4.setValue("key 1", QString("quirko"));

   479         QCOMPARE(settings1.value("key 1").toString(), QString("gurgle"));

   480         QCOMPARE(settings2.value("key 1").toString(), QString("bilboh"));

   481         QCOMPARE(settings3.value("key 1").toString(), QString("catha"));

   482         QCOMPARE(settings4.value("key 1").toString(), QString("quirko"));

   483 

   484         /*

   485             Test the copies again.

   486         */

   487         QCOMPARE(settings5.value("key 1").toString(), settings1.value("key 1").toString());

   488         QCOMPARE(settings6.value("key 1").toString(), settings2.value("key 1").toString());

   489         QCOMPARE(settings7.value("key 1").toString(), settings3.value("key 1").toString());

   490         QCOMPARE(settings8.value("key 1").toString(), settings4.value("key 1").toString());

   491 

   492         /*

   493             "General" is a problem key for .ini files.

   494         */

   495         settings1.setValue("General", 1);

   496         settings1.setValue("%General", 2);

   497         settings1.setValue("alpha", 3);

   498         settings1.setValue("General/alpha", 4);

   499         settings1.setValue("%General/alpha", 5);

   500         settings1.setValue("alpha/General", 6);

   501         settings1.setValue("alpha/%General", 7);

   502         settings1.setValue("General/General", 8);

   503         settings1.setValue("General/%General", 9);

   504         settings1.setValue("%General/General", 10);

   505         settings1.setValue("%General/%General", 11);

   506     }

   507 

   508     {

   509         /*

   510             Test that the data was stored on disk after all instances

   511             of QSettings are destroyed.

   512         */

   513 

   514         QSettings settings1(format, QSettings::UserScope, "software.org", "KillerAPP");

   515         QSettings settings2(format, QSettings::UserScope, "software.org");

   516         QSettings settings3(format, QSettings::SystemScope, "software.org", "KillerAPP");

   517         QSettings settings4(format, QSettings::SystemScope, "software.org");

   518 

   519         QCOMPARE(settings1.value("key 1").toString(), QString("gurgle"));

   520         QCOMPARE(settings2.value("key 1").toString(), QString("bilboh"));

   521         QCOMPARE(settings3.value("key 1").toString(), QString("catha"));

   522         QCOMPARE(settings4.value("key 1").toString(), QString("quirko"));

   523 

   524         /*

   525             Test problem keys.

   526         */

   527 

   528         QCOMPARE(settings1.value("General").toInt(), 1);

   529         QCOMPARE(settings1.value("%General").toInt(), 2);

   530         QCOMPARE(settings1.value("alpha").toInt(), 3);

   531         QCOMPARE(settings1.value("General/alpha").toInt(), 4);

   532         QCOMPARE(settings1.value("%General/alpha").toInt(), 5);

   533         QCOMPARE(settings1.value("alpha/General").toInt(), 6);

   534         QCOMPARE(settings1.value("alpha/%General").toInt(), 7);

   535         QCOMPARE(settings1.value("General/General").toInt(), 8);

   536         QCOMPARE(settings1.value("General/%General").toInt(), 9);

   537         QCOMPARE(settings1.value("%General/General").toInt(), 10);

   538         QCOMPARE(settings1.value("%General/%General").toInt(), 11);

   539 

   540         /*

   541             Test that the organization and product parameters is

   542             case-insensitive on Windows and Mac, case-sensitive on

   543             Unix.

   544         */

   545         QSettings settings5(format, QSettings::UserScope, "SoftWare.ORG", "killerApp");

   546         if (format == QSettings::NativeFormat) {

   547 #if defined(Q_OS_WIN) || defined(Q_OS_DARWIN) || defined(Q_OS_SYMBIAN)

   548             QCOMPARE(settings5.value("key 1").toString(), QString("gurgle"));

   549 #else

   550             QVERIFY(!settings5.contains("key 1"));

   551 #endif

   552         } else {

   553 #if defined(Q_OS_WIN) || defined(Q_OS_DARWIN) || defined(Q_OS_SYMBIAN)

   554             QCOMPARE(settings5.value("key 1").toString(), QString("gurgle"));

   555 #else

   556             QVERIFY(!settings5.contains("key 1"));

   557 #endif

   558         }

   559     }

   560 

   561     {

   562         QSettings settings1(settingsPath("custom/custom.conf"), QSettings::IniFormat);

   563         settings1.beginGroup("alpha/beta");

   564         settings1.setValue("geometry", -7);

   565         settings1.setValue("geometry/x", 1);

   566         settings1.setValue("geometry/y", 2);

   567         QSettings settings2(settingsPath("custom/custom.conf"), QSettings::IniFormat);

   568         settings1.setValue("geometry/width", 3);

   569         settings2.setValue("alpha/beta/geometry/height", 4);

   570         settings2.setValue("alpha/gamma/splitter", 5);

   571         settings1.endGroup();

   572 

   573         // test QSettings::scope() while we're at it

   574         QVERIFY(settings1.scope() == QSettings::UserScope);

   575 

   576         // test QSettings::organizationName() while we're at it

   577         QVERIFY(settings1.organizationName().isEmpty());

   578 

   579         // test QSettings::applicationName() while we're at it

   580         QVERIFY(settings1.organizationName().isEmpty());

   581 

   582         QSettings settings3(settingsPath("custom/custom2.conf"), QSettings::IniFormat);

   583         settings3.beginGroup("doodley/beta");

   584         settings3.setValue("geometry", -7);

   585         settings3.setValue("geometry/x", 1);

   586         settings3.setValue("geometry/y", 2);

   587         settings3.setValue("geometry/width", 3);

   588         settings3.setValue("geometry/height", 4);

   589         settings3.endGroup();

   590         settings3.setValue("alpha/gamma/splitter", 5);

   591 

   592         QCOMPARE(settings1.value("alpha/beta/geometry").toInt(), -7);

   593         QCOMPARE(settings1.value("alpha/beta/geometry/x").toInt(), 1);

   594         QCOMPARE(settings1.value("alpha/beta/geometry/y").toInt(), 2);

   595         QCOMPARE(settings1.value("alpha/beta/geometry/width").toInt(), 3);

   596         QCOMPARE(settings1.value("alpha/beta/geometry/height").toInt(), 4);

   597         QCOMPARE(settings1.value("alpha/gamma/splitter").toInt(), 5);

   598         QCOMPARE(settings1.allKeys().count(), 6);

   599 

   600         QCOMPARE(settings2.value("alpha/beta/geometry").toInt(), -7);

   601         QCOMPARE(settings2.value("alpha/beta/geometry/x").toInt(), 1);

   602         QCOMPARE(settings2.value("alpha/beta/geometry/y").toInt(), 2);

   603         QCOMPARE(settings2.value("alpha/beta/geometry/width").toInt(), 3);

   604         QCOMPARE(settings2.value("alpha/beta/geometry/height").toInt(), 4);

   605         QCOMPARE(settings2.value("alpha/gamma/splitter").toInt(), 5);

   606         QCOMPARE(settings2.allKeys().count(), 6);

   607     }

   608 

   609     {

   610         QSettings settings1(settingsPath("custom/custom.conf"), QSettings::IniFormat);

   611         QCOMPARE(settings1.value("alpha/beta/geometry").toInt(), -7);

   612         QCOMPARE(settings1.value("alpha/beta/geometry/x").toInt(), 1);

   613         QCOMPARE(settings1.value("alpha/beta/geometry/y").toInt(), 2);

   614         QCOMPARE(settings1.value("alpha/beta/geometry/width").toInt(), 3);

   615         QCOMPARE(settings1.value("alpha/beta/geometry/height").toInt(), 4);

   616         QCOMPARE(settings1.value("alpha/gamma/splitter").toInt(), 5);

   617         QCOMPARE(settings1.allKeys().count(), 6);

   618     }

   619 

   620     {

   621         // QSettings's default constructor is native by default

   622         if (format == QSettings::NativeFormat) {

   623             QCoreApplication::instance()->setOrganizationName("");

   624             QCoreApplication::instance()->setApplicationName("");

   625             QSettings settings;

   626             QCOMPARE(settings.status(), QSettings::AccessError);

   627             QCoreApplication::instance()->setOrganizationName("software.org");

   628             QCoreApplication::instance()->setApplicationName("KillerAPP");

   629             QSettings settings2;

   630             QCOMPARE(settings2.status(), QSettings::NoError);

   631             QSettings settings3("software.org", "KillerAPP");

   632             QCOMPARE(settings2.fileName(), settings3.fileName());

   633             QCoreApplication::instance()->setOrganizationName("");

   634             QCoreApplication::instance()->setApplicationName("");

   635         }

   636 

   637         QSettings settings(format, QSettings::UserScope, "", "");

   638         QCOMPARE(settings.status(), QSettings::AccessError);

   639         QSettings settings2(format, QSettings::UserScope, "software.org", "KillerAPP");

   640         QCOMPARE(settings2.status(), QSettings::NoError);

   641 

   642         // test QSettings::format() while we're at it

   643         QVERIFY(settings.format() == format);

   644         QVERIFY(settings2.format() == format);

   645 

   646         // test QSettings::scope() while we're at it

   647         QVERIFY(settings.scope() == QSettings::UserScope);

   648         QVERIFY(settings2.scope() == QSettings::UserScope);

   649 

   650         // test QSettings::organizationName() while we're at it

   651         QVERIFY(settings.organizationName().isEmpty());

   652         QVERIFY(settings2.organizationName() == "software.org");

   653 

   654         // test QSettings::applicationName() while we're at it

   655         QVERIFY(settings.applicationName().isEmpty());

   656         QVERIFY(settings2.applicationName() == "KillerAPP");

   657     }

   658 }

   659 

   660 void tst_QSettings::testByteArray_data()

   661 {

   662     QTest::addColumn<QByteArray>("data");

   663 

   664     QByteArray bytes("Hello world!");

   665 

   666     QTest::newRow("latin1") << bytes;

   667 #ifndef QT_NO_COMPRESS

   668     QTest::newRow("compressed") << qCompress(bytes);

   669 #endif

   670     QTest::newRow("with \\0") << bytes + '\0' + bytes;

   671 }

   672 

   673 void tst_QSettings::testByteArray()

   674 {

   675     QFETCH(QByteArray, data);

   676 

   677     // write

   678     {

   679         QSettings settings("Trolltech", "tst_qsettings");

   680         settings.setValue("byteArray", data);

   681     }

   682     // read

   683     {

   684         QSettings settings("Trolltech", "tst_qsettings");

   685         QByteArray ret = settings.value("byteArray", data).toByteArray();

   686         QCOMPARE(ret, data);

   687     }

   688 }

   689 

   690 void tst_QSettings::testErrorHandling_data()

   691 {

   692     QTest::addColumn<int>("filePerms"); // -1 means file should not exist

   693     QTest::addColumn<int>("dirPerms");

   694     QTest::addColumn<int>("statusAfterCtor");

   695     QTest::addColumn<bool>("shouldBeEmpty");

   696     QTest::addColumn<int>("statusAfterGet");

   697     QTest::addColumn<int>("statusAfterSetAndSync");

   698 

   699     //                         file    dir     afterCtor                      empty     afterGet                      afterSetAndSync

   700     QTest::newRow("0600 0700") << 0600 << 0700 << (int)QSettings::NoError     << false << (int)QSettings::NoError     << (int)QSettings::NoError;

   701 

   702     QTest::newRow("0400 0700") << 0400 << 0700 << (int)QSettings::NoError

   703         << false << (int)QSettings::NoError     << (int)QSettings::AccessError;

   704     QTest::newRow("0200 0700") << 0200 << 0700 << (int)QSettings::AccessError

   705         << true  << (int)QSettings::AccessError << (int)QSettings::AccessError;

   706 

   707     QTest::newRow("  -1 0700") <<   -1 << 0700 << (int)QSettings::NoError     << true  << (int)QSettings::NoError     << (int)QSettings::NoError;

   708 

   709     QTest::newRow("  -1 0000") <<   -1 << 0000 << (int)QSettings::NoError     << true  << (int)QSettings::NoError     << (int)QSettings::AccessError;

   710     QTest::newRow("  -1 0100") <<   -1 << 0100 << (int)QSettings::NoError     << true  << (int)QSettings::NoError     << (int)QSettings::AccessError;

   711     QTest::newRow("0600 0100") << 0600 << 0100 << (int)QSettings::NoError     << false << (int)QSettings::NoError     << (int)QSettings::NoError;

   712     QTest::newRow("  -1 0300") <<   -1 << 0300 << (int)QSettings::NoError     << true  << (int)QSettings::NoError     << (int)QSettings::NoError;

   713     QTest::newRow("0600 0300") << 0600 << 0300 << (int)QSettings::NoError     << false << (int)QSettings::NoError     << (int)QSettings::NoError;

   714     QTest::newRow("  -1 0500") <<   -1 << 0500 << (int)QSettings::NoError     << true  << (int)QSettings::NoError     << (int)QSettings::AccessError;

   715     QTest::newRow("0600 0500") << 0600 << 0500 << (int)QSettings::NoError     << false << (int)QSettings::NoError     << (int)QSettings::NoError;

   716 }

   717 

   718 void tst_QSettings::testErrorHandling()

   719 {

   720 #ifdef QT_BUILD_INTERNAL

   721 #ifdef Q_OS_WIN

   722     QSKIP("Windows doesn't support most file modes, including read-only directories, so this test is moot.", SkipAll);

   723 #elif defined(Q_OS_SYMBIAN)

   724     QSKIP("Symbian/Open C doesn't support execute or write only file modes, or directory permissions, so this test is mostly moot.", SkipAll);

   725 #elif defined(Q_OS_UNIX)

   726     if (::getuid() == 0)

   727         QSKIP("Running this test as root doesn't work, since file perms do not bother him", SkipAll);

   728 #else

   729     QFETCH(int, filePerms);

   730     QFETCH(int, dirPerms);

   731     QFETCH(int, statusAfterCtor);

   732     QFETCH(bool, shouldBeEmpty);

   733     QFETCH(int, statusAfterGet);

   734     QFETCH(int, statusAfterSetAndSync);

   735 

   736     system(QString("chmod 700 %1 2>/dev/null").arg(settingsPath("someDir")).toLatin1());

   737     system(QString("chmod -R u+rwx %1 2>/dev/null").arg(settingsPath("someDir")).toLatin1());

   738     system(QString("rm -fr %1").arg(settingsPath("someDir")).toLatin1());

   739 

   740     // prepare a file with some settings

   741     if (filePerms != -1) {

   742         QSettings settings(settingsPath("someDir/someSettings.ini"), QSettings::IniFormat);

   743         QCOMPARE((int) settings.status(), (int) QSettings::NoError);

   744 

   745         settings.beginGroup("alpha/beta");

   746         settings.setValue("geometry", -7);

   747         settings.setValue("geometry/x", 1);

   748         settings.setValue("geometry/y", 2);

   749         settings.setValue("geometry/width", 3);

   750         settings.setValue("geometry/height", 4);

   751         settings.endGroup();

   752         settings.setValue("alpha/gamma/splitter", 5);

   753     } else {

   754         system(QString("mkdir -p %1").arg(settingsPath("someDir")).toLatin1());

   755     }

   756 

   757     if (filePerms != -1) {

   758         system(QString("chmod %1 %2")

   759                     .arg(QString::number(filePerms, 8))

   760                     .arg(settingsPath("someDir/someSettings.ini"))

   761                     .toLatin1());

   762     }

   763     system(QString("chmod %1 %2")

   764                 .arg(QString::number(dirPerms, 8))

   765                 .arg(settingsPath("someDir"))

   766                 .toLatin1());

   767 

   768     // the test

   769     {

   770         QConfFile::clearCache();

   771         QSettings settings(settingsPath("someDir/someSettings.ini"), QSettings::IniFormat);

   772         QCOMPARE((int)settings.status(), statusAfterCtor);

   773         if (shouldBeEmpty) {

   774             QCOMPARE(settings.allKeys().count(), 0);

   775         } else {

   776             QVERIFY(settings.allKeys().count() > 0);

   777         }

   778         settings.value("alpha/beta/geometry");

   779         QCOMPARE((int)settings.status(), statusAfterGet);

   780         settings.setValue("alpha/beta/geometry", 100);

   781         QCOMPARE((int)settings.status(), statusAfterGet);

   782         QCOMPARE(settings.value("alpha/beta/geometry").toInt(), 100);

   783         settings.sync();

   784         QCOMPARE(settings.value("alpha/beta/geometry").toInt(), 100);

   785         QCOMPARE((int)settings.status(), statusAfterSetAndSync);

   786     }

   787 #endif // !Q_OS_WIN

   788 #endif

   789 }

   790 

   791 Q_DECLARE_METATYPE(QVariant)

   792 Q_DECLARE_METATYPE(QSettings::Status)

   793 

   794 void tst_QSettings::testIniParsing_data()

   795 {

   796     QTest::addColumn<QByteArray>("inicontent");

   797     QTest::addColumn<QString>("key");

   798     QTest::addColumn<QVariant>("expect");

   799     QTest::addColumn<QSettings::Status>("status");

   800 

   801     // Test "forgiving" parsing of entries not terminated with newline or unterminated strings

   802     QTest::newRow("good1")    << QByteArray("v=1\n")          << "v" << QVariant(1) << QSettings::NoError;

   803     QTest::newRow("good2")    << QByteArray("v=1\\\n2")       << "v" << QVariant(12) << QSettings::NoError;

   804     QTest::newRow("good3")    << QByteArray("v=1\\\r2")       << "v" << QVariant(12) << QSettings::NoError;

   805     QTest::newRow("good4")    << QByteArray("v=1\\\n\r2")     << "v" << QVariant(12) << QSettings::NoError;

   806     QTest::newRow("good5")    << QByteArray("v=1\\\r\n2")     << "v" << QVariant(12) << QSettings::NoError;

   807     QTest::newRow("good6")    << QByteArray("v  \t = \t 1\\\r\n2")     << "v" << QVariant(12) << QSettings::NoError;

   808     QTest::newRow("garbage1") << QByteArray("v")              << "v" << QVariant() << QSettings::FormatError;

   809     QTest::newRow("nonterm1") << QByteArray("v=str")          << "v" << QVariant("str") << QSettings::NoError;

   810     QTest::newRow("nonterm2") << QByteArray("v=\"str\"")      << "v" << QVariant("str") << QSettings::NoError;

   811     QTest::newRow("nonterm3") << QByteArray("v=\"str")        << "v" << QVariant("str") << QSettings::NoError;

   812     QTest::newRow("nonterm4") << QByteArray("v=\\")           << "v" << QVariant("") << QSettings::NoError;

   813     QTest::newRow("nonterm5") << QByteArray("u=s\nv=\"str")   << "v" << QVariant("str") << QSettings::NoError;

   814     QTest::newRow("nonterm6") << QByteArray("v=\"str\nw=ok")  << "v" << QVariant("str\nw=ok") << QSettings::NoError;

   815     QTest::newRow("nonterm7") << QByteArray("v=")             << "v" << QVariant("") << QSettings::NoError;

   816     QTest::newRow("nonterm8") << QByteArray("v=\"str\njnk")   << "v" << QVariant("str\njnk") << QSettings::NoError;

   817     QTest::newRow("nonterm9") << QByteArray("v=1\\")          << "v" << QVariant(1) << QSettings::NoError;

   818     QTest::newRow("nonterm10") << QByteArray("v=1\\\n")       << "v" << QVariant(1) << QSettings::NoError;

   819     QTest::newRow("nonterm11") << QByteArray("v=1\\\r")       << "v" << QVariant(1) << QSettings::NoError;

   820     QTest::newRow("nonterm12") << QByteArray("v=1\\\n\r")     << "v" << QVariant(1) << QSettings::NoError;

   821     QTest::newRow("nonterm13") << QByteArray("v=1\\\r\n")     << "v" << QVariant(1) << QSettings::NoError;

   822     QTest::newRow("nonterm14") << QByteArray("v=1\\\n\nx=2")  << "v" << QVariant(1) << QSettings::NoError;

   823     QTest::newRow("nonterm15") << QByteArray("v=1\\\r\rx=2")  << "v" << QVariant(1) << QSettings::NoError;

   824     QTest::newRow("nonterm16") << QByteArray("v=1\\\n\n\nx=2") << "v" << QVariant(1) << QSettings::NoError;

   825     QTest::newRow("nonterm17") << QByteArray("; foo\nv=1") << "v" << QVariant(1) << QSettings::NoError;

   826     QTest::newRow("nonterm18") << QByteArray("; foo\n\nv=1") << "v" << QVariant(1) << QSettings::NoError;

   827     QTest::newRow("nonterm19") << QByteArray("\nv=1;foo") << "v" << QVariant(1) << QSettings::NoError;

   828     QTest::newRow("nonterm20") << QByteArray("v=x ") << "v" << QVariant("x") << QSettings::NoError;

   829     QTest::newRow("nonterm21") << QByteArray("v=x ;") << "v" << QVariant("x") << QSettings::NoError;

   830 }

   831 

   832 void tst_QSettings::testIniParsing()

   833 {

   834 #ifdef QT_BUILD_INTERNAL

   835     qRegisterMetaType<QVariant>("QVariant");

   836     qRegisterMetaType<QSettings::Status>("QSettings::Status");

   837 

   838     QDir dir(settingsPath());

   839     QVERIFY(dir.mkpath("someDir"));

   840     QFile f(dir.path()+"/someDir/someSettings.ini");

   841 

   842     QFETCH(QByteArray, inicontent);

   843     QFETCH(QString, key);

   844     QFETCH(QVariant, expect);

   845     QFETCH(QSettings::Status, status);

   846 

   847     QVERIFY(f.open(QFile::WriteOnly));

   848     f.write(inicontent);

   849     f.close();

   850 

   851     QConfFile::clearCache();

   852     QSettings settings(settingsPath("someDir/someSettings.ini"), QSettings::IniFormat);

   853 

   854     if ( settings.status() == QSettings::NoError ) { // else no point proceeding

   855 	QVariant v = settings.value(key);

   856 	QVERIFY(v.canConvert(expect.type()));

   857 	// check some types so as to give prettier error messages

   858 	if ( v.type() == QVariant::String ) {

   859 	    QCOMPARE(v.toString(), expect.toString());

   860 	} else if ( v.type() == QVariant::Int ) {

   861 	    QCOMPARE(v.toInt(), expect.toInt());

   862 	} else {

   863 	    QCOMPARE(v, expect);

   864 	}

   865     }

   866 

   867     QCOMPARE(settings.status(), status);

   868 #endif

   869 }

   870 

   871 /*

   872     Tests beginGroup(), endGroup(), and group().

   873 */

   874 void tst_QSettings::beginGroup()

   875 {

   876     QSettings settings1(QSettings::UserScope, "software.org", "KillerAPP");

   877     QSettings settings2(QSettings::UserScope, "software.org", "KillerAPP");

   878 

   879     /*

   880       Let's start with some back and forthing.

   881     */

   882 

   883     settings1.beginGroup("alpha");

   884     QCOMPARE(settings1.group(), QString("alpha"));

   885     settings1.endGroup();

   886     QCOMPARE(settings1.group(), QString());

   887     settings1.beginGroup("/beta");

   888     QCOMPARE(settings1.group(), QString("beta"));

   889     settings1.endGroup();

   890     QCOMPARE(settings1.group(), QString());

   891 

   892     settings1.beginGroup("///gamma//");

   893     QCOMPARE(settings1.group(), QString("gamma"));

   894     settings1.endGroup();

   895     QCOMPARE(settings1.group(), QString());

   896 

   897     settings1.setValue("geometry", 5);

   898     QCOMPARE(settings1.value("geometry").toInt(), 5);

   899     QCOMPARE(settings1.value("/geometry///").toInt(), 5);

   900     QCOMPARE(settings2.value("geometry").toInt(), 5);

   901     QCOMPARE(settings2.value("/geometry///").toInt(), 5);

   902 

   903     /*

   904       OK, now start for real.

   905     */

   906 

   907     settings1.beginGroup("alpha");

   908     QCOMPARE(settings1.group(), QString("alpha"));

   909     settings1.setValue("geometry", 66);

   910     QCOMPARE(settings1.value("geometry").toInt(), 66);

   911     QCOMPARE(settings2.value("geometry").toInt(), 5);

   912     QCOMPARE(settings2.value("alpha/geometry").toInt(), 66);

   913 

   914     QSettings settings3(QSettings::UserScope, "software.org", "KillerAPP");

   915     settings3.beginGroup("alpha");

   916     QCOMPARE(settings3.value("geometry").toInt(), 66);

   917 

   918     settings1.beginGroup("/beta///");

   919     QCOMPARE(settings1.group(), QString("alpha/beta"));

   920     settings1.setValue("geometry", 777);

   921     QCOMPARE(settings1.value("geometry").toInt(), 777);

   922     QCOMPARE(settings2.value("geometry").toInt(), 5);

   923     QCOMPARE(settings2.value("alpha/geometry").toInt(), 66);

   924     QCOMPARE(settings2.value("alpha/beta/geometry").toInt(), 777);

   925     QCOMPARE(settings3.value("geometry").toInt(), 66);

   926     QCOMPARE(settings3.value("beta/geometry").toInt(), 777);

   927 

   928     settings3.beginGroup("gamma");

   929     settings3.setValue("geometry", 8888);

   930     QCOMPARE(settings3.value("geometry").toInt(), 8888);

   931     QCOMPARE(settings2.value("geometry").toInt(), 5);

   932     QCOMPARE(settings2.value("alpha/geometry").toInt(), 66);

   933     QCOMPARE(settings2.value("alpha/beta/geometry").toInt(), 777);

   934     QCOMPARE(settings2.value("alpha/gamma/geometry").toInt(), 8888);

   935     QCOMPARE(settings1.value("geometry").toInt(), 777);

   936 

   937     // endGroup() should do nothing if group() is empty

   938     for (int i = 0; i < 10; ++i)

   939         settings2.endGroup();

   940     QCOMPARE(settings2.value("geometry").toInt(), 5);

   941     QCOMPARE(settings2.value("alpha/geometry").toInt(), 66);

   942     QCOMPARE(settings2.value("alpha/beta/geometry").toInt(), 777);

   943     QCOMPARE(settings2.value("alpha/gamma/geometry").toInt(), 8888);

   944 

   945     QCOMPARE(settings1.group(), QString("alpha/beta"));

   946     settings1.endGroup();

   947     QCOMPARE(settings1.group(), QString("alpha"));

   948     settings1.endGroup();

   949     QCOMPARE(settings1.group(), QString());

   950     QCOMPARE(settings1.value("geometry").toInt(), 5);

   951     QCOMPARE(settings1.value("alpha/geometry").toInt(), 66);

   952     QCOMPARE(settings1.value("alpha/beta/geometry").toInt(), 777);

   953     QCOMPARE(settings1.value("alpha/gamma/geometry").toInt(), 8888);

   954 

   955     settings1.beginGroup("delta");

   956     QCOMPARE(settings1.group(), QString("delta"));

   957     settings1.beginGroup("");

   958     QCOMPARE(settings1.group(), QString("delta"));

   959     settings1.beginGroup("/");

   960     QCOMPARE(settings1.group(), QString("delta"));

   961     settings1.beginGroup("////");

   962     QCOMPARE(settings1.group(), QString("delta"));

   963     settings1.beginGroup("////omega///epsilon zeta eta  theta/ / /");

   964     QCOMPARE(settings1.group(), QString("delta/omega/epsilon zeta eta  theta/ / "));

   965     settings1.endGroup();

   966     QCOMPARE(settings1.group(), QString("delta"));

   967     settings1.endGroup();

   968     QCOMPARE(settings1.group(), QString("delta"));

   969     settings1.endGroup();

   970     QCOMPARE(settings1.group(), QString("delta"));

   971     settings1.endGroup();

   972     QCOMPARE(settings1.group(), QString("delta"));

   973     settings1.endGroup();

   974     QCOMPARE(settings1.group(), QString());

   975 }

   976 

   977 /*

   978     Tests setValue() and getXxx().

   979 */

   980 void tst_QSettings::setValue()

   981 {

   982     QSettings settings(QSettings::UserScope, "software.org", "KillerAPP");

   983 

   984     settings.setValue("key 2", (int)0x7fffffff);

   985     QCOMPARE(settings.value("key 2").toInt(), (int)0x7fffffff);

   986     QCOMPARE(settings.value("key 2").toString(), QString::number((int)0x7fffffff));

   987     settings.setValue("key 2", -1);

   988     QCOMPARE(settings.value("key 2").toInt(), -1);

   989     QCOMPARE(settings.value("key 2").toString(), QString("-1"));

   990     settings.setValue("key 2", (int)0x80000000);

   991     QCOMPARE(settings.value("key 2").toInt(), (int)0x80000000);

   992     settings.setValue("key 2", (int)0);

   993     QCOMPARE(settings.value("key 2", 123).toInt(), (int)0);

   994     settings.setValue("key 2", (int)12345);

   995     QCOMPARE(settings.value("key 2").toInt(), (int)12345);

   996     QCOMPARE(settings.value("no such key", 1234).toInt(), (int)1234);

   997     QCOMPARE(settings.value("no such key").toInt(), (int)0);

   998 

   999     settings.setValue("key 2", true);

  1000     QCOMPARE(settings.value("key 2").toBool(), true);

  1001     settings.setValue("key 2", false);

  1002     QCOMPARE(settings.value("key 2", true).toBool(), false);

  1003     settings.setValue("key 2", (int)1);

  1004     QCOMPARE(settings.value("key 2").toBool(), true);

  1005     settings.setValue("key 2", (int)-1);

  1006     QCOMPARE(settings.value("key 2").toBool(), true);

  1007     settings.setValue("key 2", (int)0);

  1008     QCOMPARE(settings.value("key 2", true).toBool(), false);

  1009     settings.setValue("key 2", QString("true"));

  1010     QCOMPARE(settings.value("key 2").toBool(), true);

  1011     settings.setValue("key 2", QString("false"));

  1012     QCOMPARE(settings.value("key 2", true).toBool(), false);

  1013 /*

  1014     settings.setValue("key 2", "true");

  1015     QCOMPARE(settings.value("key 2").toBool(), true);

  1016     settings.setValue("key 2", "false");

  1017     QCOMPARE(settings.value("key 2", true).toBool(), false);

  1018     settings.setValue("key 2", "");

  1019     QCOMPARE(settings.value("key 2", true).toBool(), true);

  1020     settings.setValue("key 2", "");

  1021     QCOMPARE(settings.value("key 2", false).toBool(), false);

  1022     settings.setValue("key 2", "0.000e-00"); // cannot convert double to a bool

  1023     QCOMPARE(settings.value("key 2", true).toBool(), true);

  1024     settings.setValue("key 2", "0.000e-00");

  1025     QCOMPARE(settings.value("key 2", false).toBool(), false);

  1026 

  1027 */

  1028     settings.setValue("key 2", QStringList());

  1029     QCOMPARE(settings.value("key 2").toStringList(), QStringList());

  1030     settings.setValue("key 2", QStringList(""));

  1031     QCOMPARE(settings.value("key 2").toStringList(), QStringList(""));

  1032     settings.setValue("key 2", QStringList() << "" << "");

  1033     QCOMPARE(settings.value("key 2").toStringList(), QStringList() << "" << "");

  1034     settings.setValue("key 2", QStringList() << "" << "a" << "" << "bc" << "");

  1035     QCOMPARE(settings.value("key 2").toStringList(), QStringList() << "" << "a" << "" << "bc" << "");

  1036 

  1037     settings.setValue("key 3", QList<QVariant>());

  1038     QCOMPARE(settings.value("key 3").toList(), QList<QVariant>());

  1039     settings.setValue("key 3", QList<QVariant>() << 1 << QString("a"));

  1040     QCOMPARE(settings.value("key 3").toList(), QList<QVariant>() << 1 << QString("a"));

  1041 

  1042     QList<QVariant> outerList;

  1043     outerList << 1 << QString("b");

  1044     QList<QVariant> innerList = outerList;

  1045     outerList.append(QVariant(innerList));

  1046     outerList.append(QVariant(innerList));

  1047     outerList << 2 << QString("c");

  1048     innerList = outerList;

  1049     outerList.append(QVariant(innerList));

  1050     // outerList: [1, "b", [1, "b"], [1, "b"], 2, "c", [1, "b", [1, "b"], [1, "b"], 2, "c"]]

  1051 

  1052     settings.setValue("key 3", outerList);

  1053     QCOMPARE(settings.value("key 3").toList(), outerList);

  1054     QCOMPARE(settings.value("key 3").toList().size(), 7);

  1055 

  1056     QMap<QString, QVariant> map;

  1057     map.insert("1", "one");

  1058     map.insert("2", "two");

  1059     map.insert("3", outerList);

  1060     map.insert("5", "cinco");

  1061     map.insert("10", "zehn");

  1062     settings.setValue("key 4", map);

  1063     QCOMPARE(settings.value("key 4").toMap(), map);

  1064 }

  1065 

  1066 void tst_QSettings::testVariantTypes_data()

  1067 {

  1068     populateWithFormats();

  1069 }

  1070 

  1071 void tst_QSettings::testVariantTypes()

  1072 {

  1073 #ifdef QT_BUILD_INTERNAL

  1074 #define testVal(key, val, tp, rtype) \

  1075     { \

  1076         QSettings settings1(format, QSettings::UserScope, "software.org", "KillerAPP"); \

  1077         settings1.setValue(key, qVariantFromValue(val)); \

  1078     } \

  1079     QConfFile::clearCache(); \

  1080     { \

  1081         QSettings settings2(format, QSettings::UserScope, "software.org", "KillerAPP"); \

  1082         QVariant v = settings2.value(key); \

  1083         QVERIFY(qvariant_cast<tp >(v) == val); \

  1084         QVERIFY(v.type() == QVariant::rtype); \

  1085     }

  1086 

  1087     typedef QMap<QString, QVariant> TestVariantMap;

  1088 

  1089     QFETCH(QSettings::Format, format);

  1090 

  1091     TestVariantMap m2;

  1092     m2.insert("ene", "due");

  1093     m2.insert("rike", "fake");

  1094     m2.insert("borba", "dorba");

  1095     testVal("key2", m2, TestVariantMap, Map);

  1096 

  1097     QStringList l2;

  1098 

  1099     l2 << "ene" << "due" << "@Point(1 2)" << "@fake";

  1100     testVal("key3", l2, QStringList, StringList);

  1101 

  1102     l2.clear();

  1103     l2 << "ene" << "due" << "rike" << "fake";

  1104     testVal("key3", l2, QStringList, StringList);

  1105 

  1106     QList<QVariant> l3;

  1107     QDate date = QDate::currentDate();

  1108     QTime time = QTime::currentTime();

  1109     l3 << QString("ene") << 10 << qVariantFromValue(QColor(1, 2, 3)) << QVariant(QRect(1, 2, 3, 4))

  1110         << QVariant(QSize(4, 56)) << QVariant(QPoint(4, 2)) << true << false << date << time;

  1111     testVal("key3", l3, QVariantList, List);

  1112 

  1113     testVal("key4", QString("hello"), QString, String);

  1114     testVal("key5", QColor(1, 2, 3), QColor, Color);

  1115     testVal("key6", QRect(1, 2, 3, 4), QRect, Rect);

  1116     testVal("key7", QSize(4, 56), QSize, Size);

  1117     testVal("key8", QPoint(4, 2), QPoint, Point);

  1118     testVal("key10", date, QDate, Date);

  1119     testVal("key11", time, QTime, Time);

  1120     testVal("key12", QByteArray("foo bar"), QByteArray, ByteArray);

  1121 

  1122     {

  1123         QSettings settings(format, QSettings::UserScope, "software.org", "KillerAPP");

  1124         QVERIFY(!settings.contains("key99"));

  1125         QCOMPARE(settings.value("key99"), QVariant());

  1126 

  1127         settings.setValue("key99", QVariant());

  1128         QVERIFY(settings.contains("key99"));

  1129         QCOMPARE(settings.value("key99"), QVariant());

  1130 

  1131         settings.setValue("key99", QVariant(1));

  1132         QVERIFY(settings.contains("key99"));

  1133         QCOMPARE(settings.value("key99"), QVariant(1));

  1134