1 #include "test-gconf.h"

     2 

     3 #define MYLOGLEVEL 2

     4 void myMessageOutput(QtMsgType type, const char *msg)

     5 {

     6     switch (type) {

     7     case QtDebugMsg:

     8         if (MYLOGLEVEL <= 0)

     9             fprintf(stderr, "Debug: %s\n", msg);

    10         break;

    11     case QtWarningMsg:

    12         if (MYLOGLEVEL <= 1)

    13             fprintf(stderr, "Warning: %s\n", msg);

    14         break;

    15     case QtCriticalMsg:

    16         if (MYLOGLEVEL <= 2)

    17             fprintf(stderr, "Critical: %s\n", msg);

    18         break;

    19     case QtFatalMsg:

    20         if (MYLOGLEVEL <= 3)

    21             fprintf(stderr, "Fatal: %s\n", msg);

    22         abort();

    23     }

    24 }

    25 

    26 //

    27 // Definition of testcases: Normal tests

    28 //

    29 

    30 void GConfItemTests::timeout()

    31 {

    32     timed_out = true;

    33     timer.stop();

    34 }

    35 

    36 // Before all tests

    37 void GConfItemTests::initTestCase()

    38 {

    39     connect(&timer, SIGNAL(timeout()),

    40             this, SLOT(timeout()));

    41 }

    42 

    43 // After all tests

    44 void GConfItemTests::cleanupTestCase()

    45 {

    46 }

    47 

    48 // Before each test

    49 void GConfItemTests::init()

    50 {

    51     boolItem = new GConfItem("/Test/Bool");

    52     intItem = new GConfItem("/Test/Int");

    53     stringItem = new GConfItem("/Test/String");

    54     doubleItem = new GConfItem("/Test/Double");

    55     stringListItem = new GConfItem("/Test/StringList");

    56     intListItem = new GConfItem("/Test/IntList");

    57     doubleListItem = new GConfItem("/Test/DoubleList");

    58     boolListItem = new GConfItem("/Test/BoolList");

    59     unsetBeforeItem = new GConfItem("/Test/UnsetBefore");

    60     unsetAfterItem = new GConfItem("/Test/UnsetAfter");

    61     signalSpy = new SignalListener();

    62     QObject::connect(boolItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    63     QObject::connect(intItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    64     QObject::connect(stringItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    65     QObject::connect(doubleItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    66     QObject::connect(stringListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    67     QObject::connect(intListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    68     QObject::connect(doubleListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    69     QObject::connect(boolListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    70 }

    71 

    72 // After each test

    73 void GConfItemTests::cleanup()

    74 {

    75     QObject::disconnect(boolItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    76     QObject::disconnect(intItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    77     QObject::disconnect(stringItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    78     QObject::disconnect(doubleItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    79     QObject::disconnect(stringListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    80     QObject::disconnect(intListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    81     QObject::disconnect(doubleListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    82     QObject::disconnect(boolListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));

    83     delete signalSpy;

    84     delete boolItem;

    85     delete intItem;

    86     delete stringItem;

    87     delete doubleItem;

    88     delete stringListItem;

    89     delete intListItem;

    90     delete doubleListItem;

    91     delete boolListItem;

    92     delete unsetBeforeItem;

    93     delete unsetAfterItem;

    94 

    95     timer.stop();

    96 }

    97 

    98 void GConfItemTests::path()

    99 {

   100     QCOMPARE(boolItem->key(), QString("/Test/Bool"));

   101     QCOMPARE(intItem->key(), QString("/Test/Int"));

   102     QCOMPARE(stringItem->key(), QString("/Test/String"));

   103     QCOMPARE(doubleItem->key(), QString("/Test/Double"));

   104     QCOMPARE(stringListItem->key(), QString("/Test/StringList"));

   105     QCOMPARE(intListItem->key(), QString("/Test/IntList"));

   106     QCOMPARE(doubleListItem->key(), QString("/Test/DoubleList"));

   107     QCOMPARE(boolListItem->key(), QString("/Test/BoolList"));

   108     QCOMPARE(unsetBeforeItem->key(), QString("/Test/UnsetBefore"));

   109     QCOMPARE(unsetAfterItem->key(), QString("/Test/UnsetAfter"));

   110 }

   111 

   112 void GConfItemTests::external_values()

   113 {

   114     // These values are set before this program starts.

   115     QCOMPARE(boolItem->value().toBool(), true);

   116     QCOMPARE(intItem->value().toInt(), 123);

   117     QCOMPARE(stringItem->value().toString(), QString("Hello GConf"));

   118     QCOMPARE(doubleItem->value().toDouble(), 3.5);

   119     QCOMPARE(stringListItem->value().toStringList(), QStringList() << "Hello" << "GConf" << QString::fromUtf8("ÄÖÜ"));

   120     QCOMPARE(intListItem->value().toList(), QList<QVariant>() << 1 << 2 << 3 << 4);

   121     QCOMPARE(doubleListItem->value().toList(), QList<QVariant>() << 3.5 << 3.5 << 3.5);

   122     QCOMPARE(boolListItem->value().toList(), QList<QVariant>() << false << true << true << false);

   123     QCOMPARE(unsetBeforeItem->value().isValid(), false);

   124     QCOMPARE(unsetAfterItem->value().isValid(), true);

   125 }

   126 

   127 void GConfItemTests::set_bool()

   128 {

   129     signalSpy->numberOfCalls = 0;

   130 

   131     boolItem->set(false);

   132     QCOMPARE(boolItem->value().toBool(), false);

   133     boolItem->set(true);

   134     QCOMPARE(boolItem->value().toBool(), true);

   135 

   136     QCOMPARE(signalSpy->numberOfCalls, 2);

   137 }

   138 

   139 void GConfItemTests::set_int()

   140 {

   141     signalSpy->numberOfCalls = 0;

   142 

   143     intItem->set(12);

   144     QCOMPARE(intItem->value().toInt(), 12);

   145     intItem->set(-5);

   146     QCOMPARE(intItem->value().toInt(), -5);

   147 

   148     QCOMPARE(signalSpy->numberOfCalls, 2);

   149 }

   150 

   151 void GConfItemTests::set_string()

   152 {

   153     signalSpy->numberOfCalls = 0;

   154 

   155     stringItem->set("Hi");

   156     QCOMPARE(stringItem->value().toString(), QString("Hi"));

   157 

   158     QCOMPARE(signalSpy->numberOfCalls, 1);

   159 }

   160 

   161 void GConfItemTests::set_unicode_string()

   162 {

   163     signalSpy->numberOfCalls = 0;

   164 

   165     stringItem->set(QString::fromUtf8("Höäü"));

   166     QCOMPARE(stringItem->value().toString(), QString::fromUtf8("Höäü"));

   167 

   168     QCOMPARE(signalSpy->numberOfCalls, 1);

   169 }

   170 

   171 void GConfItemTests::set_double()

   172 {

   173     signalSpy->numberOfCalls = 0;

   174 

   175     doubleItem->set(1.2345);

   176     QCOMPARE(doubleItem->value().toDouble(), 1.2345);

   177 

   178     QCOMPARE(signalSpy->numberOfCalls, 1);

   179 }

   180 

   181 void GConfItemTests::set_string_list()

   182 {

   183     signalSpy->numberOfCalls = 0;

   184 

   185     stringListItem->set(QStringList() << "one" << "two" << "three");

   186     QCOMPARE(stringListItem->value().toStringList(), QStringList() << "one" << "two" << "three");

   187 

   188     QCOMPARE(signalSpy->numberOfCalls, 1);

   189 }

   190 

   191 void GConfItemTests::set_int_list()

   192 {

   193     signalSpy->numberOfCalls = 0;

   194 

   195     intListItem->set(QList<QVariant>() << 10 << 11 << 12);

   196     QCOMPARE(intListItem->value().toList(), QList<QVariant>() << 10 << 11 << 12);

   197 

   198     QCOMPARE(signalSpy->numberOfCalls, 1);

   199 }

   200 

   201 void GConfItemTests::set_double_list()

   202 {

   203     signalSpy->numberOfCalls = 0;

   204 

   205     doubleListItem->set(QList<QVariant>() << 1.1 << 2.2 << 3.3);

   206     QCOMPARE(doubleListItem->value().toList(), QList<QVariant>() << 1.1 << 2.2 << 3.3);

   207 

   208     QCOMPARE(signalSpy->numberOfCalls, 1);

   209 }

   210 

   211 void GConfItemTests::set_bool_list()

   212 {

   213     signalSpy->numberOfCalls = 0;

   214 

   215     boolListItem->set(QList<QVariant>() << true << true << false);

   216     QCOMPARE(boolListItem->value().toList(), QList<QVariant>() << true << true << false);

   217 

   218     QCOMPARE(signalSpy->numberOfCalls, 1);

   219 }

   220 

   221 void GConfItemTests::unset ()

   222 {

   223     signalSpy->numberOfCalls = 0;

   224 

   225     boolItem->unset();

   226     QCOMPARE(boolItem->value().isValid(), false);

   227 

   228     QCOMPARE(signalSpy->numberOfCalls, 1);

   229 }

   230 

   231 void GConfItemTests::list_dirs ()

   232 {

   233     GConfItem test("/Test");

   234     QStringList dirs = test.listDirs();

   235 

   236     QVERIFY (!dirs.contains("/Test/Bool"));

   237     QVERIFY (!dirs.contains("/Test/Int"));

   238     QVERIFY (!dirs.contains("/Test/String"));

   239     QVERIFY (!dirs.contains("/Test/Double"));

   240     QVERIFY (!dirs.contains("/Test/StringList"));

   241     QVERIFY (!dirs.contains("/Test/IntList"));

   242     QVERIFY (!dirs.contains("/Test/DoubleList"));

   243     QVERIFY (!dirs.contains("/Test/BoolList"));

   244     QVERIFY (!dirs.contains("/Test/UnsetBefore"));

   245     QVERIFY (!dirs.contains("/Test/UnsetAfter"));

   246     QVERIFY (dirs.contains("/Test/Dir"));

   247 }

   248 

   249 void GConfItemTests::list_entries ()

   250 {

   251     GConfItem test("/Test");

   252     QStringList entries = test.listEntries();

   253 

   254     QVERIFY (!entries.contains("/Test/Bool"));  // has been unset above

   255     QVERIFY (entries.contains("/Test/Int"));

   256     QVERIFY (entries.contains("/Test/String"));

   257     QVERIFY (entries.contains("/Test/Double"));

   258     QVERIFY (entries.contains("/Test/StringList"));

   259     QVERIFY (entries.contains("/Test/IntList"));

   260     QVERIFY (entries.contains("/Test/DoubleList"));

   261     QVERIFY (entries.contains("/Test/BoolList"));

   262     QVERIFY (!entries.contains("/Test/UnsetBefore"));

   263     QVERIFY (entries.contains("/Test/UnsetAfter"));

   264     QVERIFY (!entries.contains("/Test/Dir"));

   265 }

   266 

   267 void GConfItemTests::get_default ()

   268 {

   269     intItem->unset();

   270     QCOMPARE(intItem->value(123).toInt(), 123);

   271     intItem->set(234);

   272     QCOMPARE(intItem->value(123).toInt(), 234);

   273 }

   274 

   275 void GConfItemTests::propagate ()

   276 {

   277     GConfItem secondIntItem("/Test/Int");

   278     secondIntItem.set(3000);

   279     QVERIFY_TIMEOUT(2000, intItem->value() == secondIntItem.value());

   280     QCOMPARE(signalSpy->numberOfCalls, 2);

   281 }

   282 

   283 void GConfItemTests::set_external()

   284 {

   285     // This must be the last test case.  The values that are set here

   286     // are checked after this program exits.

   287 

   288     boolItem->set(false);

   289     intItem->set(54321);

   290     stringItem->set("Good bye GConf");

   291     doubleItem->set(-2.5);

   292     stringListItem->set(QStringList() << "Good" << "bye" << "GConf" << QString::fromUtf8("äöü"));

   293     intListItem->set(QList<QVariant>() << 5 << 4 << 3 << 2 << 1);

   294     doubleListItem->set(QList<QVariant>() << -2.5 << -2.5);

   295     boolListItem->set(QList<QVariant>() << false << false << true << true);

   296     unsetAfterItem->set(QVariant());

   297 }

   298 

   299 QTEST_MAIN(GConfItemTests);