settingstest.cpp

Go to the documentation of this file.

 
#include "settingstest.h"
 
#include <QtTest/QtTest>
 
#include "libssu/ssusettings_p.h"
#include "upgradetesthelper.h"
 
void SettingsTest::initTestCase()
{
 
}
 
void SettingsTest::cleanupTestCase()
{
 
}
 
void SettingsTest::testMerge_data()
{
    // Key names state which file(s) a key is set in (master, foo or bar). Value
    // is always in form "<file>-value" based on which file it is taken from.
 
    const QScopedPointer<QTemporaryFile> masterFile(
        QTemporaryFile::createLocalFile(":/testdata/merge/settings.ini"));
    QSettings master(masterFile->fileName(), QSettings::IniFormat);
 
    const QStringList settingsFiles = QStringList()
                                      << ":/testdata/merge/settings.d/bar.ini"
                                      << ":/testdata/merge/settings.d/foo.ini";
 
    SsuSettings::merge(&master, settingsFiles);
 
    QSettings expected(":/testdata/merge/merged.ini", QSettings::IniFormat);
 
    const QSet<QString> masterKeys = master.allKeys().toSet();
    const QSet<QString> expectedKeys = expected.allKeys().toSet();
 
    QTest::addColumn<bool>("keyIsMerged");
    QTest::addColumn<bool>("keyShouldBeMerged");
    QTest::addColumn<QString>("actualValue");
    QTest::addColumn<QString>("expectedValue");
 
    foreach (const QString &key, masterKeys + expectedKeys) {
        QTest::newRow(qPrintable(key))
                << masterKeys.contains(key)
                << expectedKeys.contains(key)
                << master.value(key).toString()
                << expected.value(key).toString();
    }
}
 
void SettingsTest::testMerge()
{
    QFETCH(bool, keyIsMerged);
    QFETCH(bool, keyShouldBeMerged);
    QFETCH(QString, actualValue);
    QFETCH(QString, expectedValue);
 
    QCOMPARE(keyIsMerged, keyShouldBeMerged);
    QCOMPARE(actualValue, expectedValue);
}
 
void SettingsTest::testUpgrade_data()
{
    // Read recipe
    QFile recipe(":/testdata/upgrade/recipe");
    QVERIFY(recipe.open(QIODevice::ReadOnly));
    QList<UpgradeTestHelper::TestCase> testCases = UpgradeTestHelper::readRecipe(&recipe);
 
    // Generate settings file according to recipe
    QTemporaryFile settingsFile;
    QVERIFY(settingsFile.open() == true);
 
    QSettings settings(settingsFile.fileName(), QSettings::IniFormat);
 
    UpgradeTestHelper::fillSettings(&settings, testCases);
 
    // Generate defaults file according to recipe
    QTemporaryFile defaultSettingsFile;
    QVERIFY(defaultSettingsFile.open() == true);
 
    QSettings defaultSettings(defaultSettingsFile.fileName(), QSettings::IniFormat);
 
    UpgradeTestHelper::fillDefaultSettings(&defaultSettings, testCases);
 
    // Parse settings -- do upgrade
#if 0
    settingsFile.seek(0);
    defaultSettingsFile.seek(0);
    qDebug() << "SETTINGS {{{\n" << settingsFile.readAll() << "\n}}}";
    qDebug() << "DEFAULT SETTINGS {{{\n" << defaultSettingsFile.readAll() << "\n}}}";
#endif
 
    SsuSettings ssuSettings(settingsFile.fileName(), QSettings::IniFormat,
                            defaultSettingsFile.fileName());
 
#if 0
    settingsFile.seek(0);
    qDebug() << "SETTINGS UPGRADED {{{\n" << settingsFile.readAll() << "\n}}}";
#endif
 
    // Record data for verification phase
    QTest::addColumn<bool>("keyIsSet");
    QTest::addColumn<bool>("keyShouldBeSet");
    QTest::addColumn<QString>("actualValue");
    QTest::addColumn<QString>("expectedValue");
 
    foreach (const UpgradeTestHelper::TestCase &testCase, testCases) {
        foreach (const QString &group, UpgradeTestHelper::groups()) {
            const QString key = group.isEmpty() ? testCase.key() : group + '/' + testCase.key();
            QTest::newRow(qPrintable(QString("%1%2:%3:%4")
                                     .arg(group.isEmpty() ? "" : group + "/")
                                     .arg(testCase.history())
                                     .arg(testCase.current())
                                     .arg(testCase.expected())))
                    << ssuSettings.contains(key)
                    << testCase.keyShouldBeSet()
                    << ssuSettings.value(key).toString()
                    << testCase.expected();
        }
    }
}
 
void SettingsTest::testUpgrade()
{
    QFETCH(bool, keyIsSet);
    QFETCH(bool, keyShouldBeSet);
    QFETCH(QString, actualValue);
    QFETCH(QString, expectedValue);
 
    QCOMPARE(keyIsSet, keyShouldBeSet);
    if (keyIsSet) {
        QCOMPARE(actualValue, expectedValue);
    }
}