← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to tests/statesavingobjecttest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-12-21 23:19:11 UTC
  • mfrom: (1.2.33 upstream) (3.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20101221231911-z9jip7s5aht1jqn9
Tags: 2:1.7.0-1ubuntu1
* Merge from Debian Experimental. Remaining Ubuntu changes:
  - Export .pot name and copy to plugins in debian/rules
  - Version build-depends on kipi-plugins-dev to ensure build is against the
    same version on all archs
* Drop debian/patches/kubuntu_01_linker.diff, incoporated upstream
* Remove patches directory and unused patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/statesavingobjecttest.cpp
 
1
/* ============================================================
 
2
 *
 
3
 * This file is a part of digiKam project
 
4
 * http://www.digikam.org
 
5
 *
 
6
 * Date        : 2009-12-23
 
7
 * Description : a test for the StateSavingObject class
 
8
 *
 
9
 * Copyright (C) 2009 by Johannes Wienke <languitar at semipol dot de>
 
10
 *
 
11
 * This program is free software; you can redistribute it
 
12
 * and/or modify it under the terms of the GNU General
 
13
 * Public License as published by the Free Software Foundation;
 
14
 * either version 2, or (at your option)
 
15
 * any later version.
 
16
 *
 
17
 * This program is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 * GNU General Public License for more details.
 
21
 *
 
22
 * ============================================================ */
 
23
 
 
24
#include "statesavingobjecttest.moc"
 
25
 
 
26
// Qt includes
 
27
 
 
28
#include <qbuffer.h>
 
29
 
 
30
// KDE includes
 
31
 
 
32
#include <kconfiggroup.h>
 
33
#include <kglobal.h>
 
34
#include <ksharedconfig.h>
 
35
 
 
36
// Local includes
 
37
 
 
38
#include "statesavingobject.h"
 
39
 
 
40
using namespace Digikam;
 
41
 
 
42
QTEST_MAIN(StateSavingObjectTest)
 
43
 
 
44
class StubStateSaverPriv
 
45
{
 
46
public:
 
47
 
 
48
    StubStateSaverPriv() :
 
49
        loadCalls(0),
 
50
        saveCalls(0)
 
51
    {
 
52
    }
 
53
 
 
54
    unsigned int loadCalls;
 
55
    unsigned int saveCalls;
 
56
};
 
57
 
 
58
StubStateSaver::StubStateSaver(QObject* parent)
 
59
    : QObject(parent), StateSavingObject(this), d(new StubStateSaverPriv)
 
60
{
 
61
}
 
62
 
 
63
StubStateSaver::~StubStateSaver()
 
64
{
 
65
    delete d;
 
66
}
 
67
 
 
68
KConfigGroup StubStateSaver::getGroup()
 
69
{
 
70
    return getConfigGroup();
 
71
}
 
72
 
 
73
QString StubStateSaver::getEntryKey(const QString& base)
 
74
{
 
75
    return entryName(base);
 
76
}
 
77
 
 
78
void StubStateSaver::doLoadState()
 
79
{
 
80
    d->loadCalls++;
 
81
}
 
82
 
 
83
void StubStateSaver::doSaveState()
 
84
{
 
85
    d->saveCalls++;
 
86
}
 
87
 
 
88
bool StubStateSaver::loadCalled()
 
89
{
 
90
    return d->loadCalls > 0;
 
91
}
 
92
 
 
93
bool StubStateSaver::saveCalled()
 
94
{
 
95
    return d->saveCalls > 0;
 
96
}
 
97
 
 
98
unsigned int StubStateSaver::numLoadCalls()
 
99
{
 
100
    return d->loadCalls;
 
101
}
 
102
 
 
103
unsigned int StubStateSaver::numSaveCalls()
 
104
{
 
105
    return d->saveCalls;
 
106
}
 
107
 
 
108
// -----------------------------------------------------------------------------
 
109
 
 
110
void StateSavingObjectTest::testGroupName()
 
111
{
 
112
 
 
113
    StubStateSaver saver;
 
114
    QCOMPARE(saver.getGroup().name(), QString("<default>"));
 
115
 
 
116
    const QString name = "testName 2";
 
117
    saver.setObjectName(name);
 
118
    QCOMPARE(saver.getGroup().name(), name);
 
119
 
 
120
    KConfigGroup group = KGlobal::config()->group("SimpleTest Group");
 
121
    saver.setConfigGroup(group);
 
122
    QCOMPARE(saver.getGroup().name(), group.name());
 
123
 
 
124
    // setting object name must not change returned group
 
125
    saver.setObjectName("new Name");
 
126
    QCOMPARE(saver.getGroup().name(), group.name());
 
127
 
 
128
    // resetting group must work
 
129
    KConfigGroup group2 = KGlobal::config()->group("Another SimpleTest Group");
 
130
    saver.setConfigGroup(group2);
 
131
    QCOMPARE(saver.getGroup().name(), group2.name());
 
132
 
 
133
}
 
134
 
 
135
void StateSavingObjectTest::testPrefixUsage()
 
136
{
 
137
 
 
138
    // default, empty prefix
 
139
    StubStateSaver saver;
 
140
    QCOMPARE(saver.getEntryKey(""), QString(""));
 
141
    QCOMPARE(saver.getEntryKey("test"), QString("test"));
 
142
 
 
143
    const QString prefix = " _Pr efix_ ";
 
144
    saver.setEntryPrefix(prefix);
 
145
    QCOMPARE(saver.getEntryKey(""), prefix);
 
146
    QCOMPARE(saver.getEntryKey("test"), prefix + QString("test"));
 
147
 
 
148
}
 
149
 
 
150
void StateSavingObjectTest::testDirectCalling()
 
151
{
 
152
 
 
153
    StubStateSaver loader;
 
154
    QVERIFY(!loader.loadCalled());
 
155
    loader.loadState();
 
156
    QVERIFY(loader.loadCalled());
 
157
    QVERIFY(!loader.saveCalled());
 
158
 
 
159
    StubStateSaver saver;
 
160
    QVERIFY(!saver.saveCalled());
 
161
    saver.saveState();
 
162
    QVERIFY(saver.saveCalled());
 
163
    QVERIFY(!saver.loadCalled());
 
164
 
 
165
}
 
166
 
 
167
void StateSavingObjectTest::testDirectChildrenLoading()
 
168
{
 
169
 
 
170
    StubStateSaver* parentSaver = new StubStateSaver(0);
 
171
    StubStateSaver* directChild1 = new StubStateSaver(parentSaver);
 
172
    StubStateSaver* directChild2 = new StubStateSaver(parentSaver);
 
173
    StubStateSaver* indirectChild = new StubStateSaver(directChild1);
 
174
 
 
175
    parentSaver->setStateSavingDepth(StateSavingObject::DIRECT_CHILDREN);
 
176
 
 
177
    parentSaver->loadState();
 
178
 
 
179
    QVERIFY(parentSaver->loadCalled());
 
180
    QVERIFY(directChild1->loadCalled());
 
181
    QVERIFY(directChild2->loadCalled());
 
182
    QVERIFY(!indirectChild->loadCalled());
 
183
 
 
184
    QVERIFY(!parentSaver->saveCalled());
 
185
    QVERIFY(!directChild1->saveCalled());
 
186
    QVERIFY(!directChild2->saveCalled());
 
187
    QVERIFY(!indirectChild->saveCalled());
 
188
 
 
189
    delete parentSaver;
 
190
 
 
191
}
 
192
 
 
193
void StateSavingObjectTest::testDirectChildrenSaving()
 
194
{
 
195
 
 
196
    StubStateSaver* parentSaver = new StubStateSaver(0);
 
197
    StubStateSaver* directChild1 = new StubStateSaver(parentSaver);
 
198
    StubStateSaver* directChild2 = new StubStateSaver(parentSaver);
 
199
    StubStateSaver* indirectChild = new StubStateSaver(directChild1);
 
200
 
 
201
    parentSaver->setStateSavingDepth(StateSavingObject::DIRECT_CHILDREN);
 
202
 
 
203
    parentSaver->saveState();
 
204
 
 
205
    QVERIFY(parentSaver->saveCalled());
 
206
    QVERIFY(directChild1->saveCalled());
 
207
    QVERIFY(directChild2->saveCalled());
 
208
    QVERIFY(!indirectChild->saveCalled());
 
209
 
 
210
    QVERIFY(!parentSaver->loadCalled());
 
211
    QVERIFY(!directChild1->loadCalled());
 
212
    QVERIFY(!directChild2->loadCalled());
 
213
    QVERIFY(!indirectChild->loadCalled());
 
214
 
 
215
    delete parentSaver;
 
216
 
 
217
}
 
218
 
 
219
void StateSavingObjectTest::testRecursiveChildrenLoading()
 
220
{
 
221
 
 
222
    StubStateSaver* parentSaver = new StubStateSaver(0);
 
223
    StubStateSaver* directChild1 = new StubStateSaver(parentSaver);
 
224
    StubStateSaver* directChild2 = new StubStateSaver(parentSaver);
 
225
    StubStateSaver* indirectChild1 = new StubStateSaver(directChild1);
 
226
    StubStateSaver* indirectChild2 = new StubStateSaver(directChild2);
 
227
    StubStateSaver* indirectChild3 = new StubStateSaver(directChild2);
 
228
    QBuffer* directChildStateless = new QBuffer(parentSaver);
 
229
    StubStateSaver* indirectStatelessChild = new StubStateSaver(directChildStateless);
 
230
 
 
231
    parentSaver->setStateSavingDepth(StateSavingObject::RECURSIVE);
 
232
    directChild1->setStateSavingDepth(StateSavingObject::RECURSIVE);
 
233
 
 
234
    parentSaver->loadState();
 
235
 
 
236
    QVERIFY(parentSaver->loadCalled());
 
237
    QVERIFY(directChild1->loadCalled());
 
238
    QVERIFY(directChild2->loadCalled());
 
239
    QVERIFY(indirectChild1->loadCalled());
 
240
    QVERIFY(indirectChild2->loadCalled());
 
241
    QVERIFY(indirectChild3->loadCalled());
 
242
    QVERIFY(indirectStatelessChild->loadCalled());
 
243
 
 
244
    const unsigned int desiredCalls = 1;
 
245
    QCOMPARE(parentSaver->numLoadCalls(), desiredCalls);
 
246
    QCOMPARE(directChild1->numLoadCalls(), desiredCalls);
 
247
    QCOMPARE(directChild2->numLoadCalls(), desiredCalls);
 
248
    QCOMPARE(indirectChild1->numLoadCalls(), desiredCalls);
 
249
    QCOMPARE(indirectChild2->numLoadCalls(), desiredCalls);
 
250
    QCOMPARE(indirectChild3->numLoadCalls(), desiredCalls);
 
251
    QCOMPARE(indirectStatelessChild->numLoadCalls(), desiredCalls);
 
252
 
 
253
    QCOMPARE(directChild1->getStateSavingDepth(), StateSavingObject::RECURSIVE);
 
254
 
 
255
    delete parentSaver;
 
256
 
 
257
}
 
258
 
 
259
void StateSavingObjectTest::testRecursiveChildrenSaving()
 
260
{
 
261
 
 
262
    StubStateSaver* parentSaver = new StubStateSaver(0);
 
263
    StubStateSaver* directChild1 = new StubStateSaver(parentSaver);
 
264
    StubStateSaver* directChild2 = new StubStateSaver(parentSaver);
 
265
    StubStateSaver* indirectChild1 = new StubStateSaver(directChild1);
 
266
    StubStateSaver* indirectChild2 = new StubStateSaver(directChild2);
 
267
    StubStateSaver* indirectChild3 = new StubStateSaver(directChild2);
 
268
    QBuffer* directChildStateless = new QBuffer(parentSaver);
 
269
    StubStateSaver* indirectStatelessChild = new StubStateSaver(directChildStateless);
 
270
 
 
271
    parentSaver->setStateSavingDepth(StateSavingObject::RECURSIVE);
 
272
    directChild1->setStateSavingDepth(StateSavingObject::RECURSIVE);
 
273
 
 
274
    parentSaver->saveState();
 
275
 
 
276
    QVERIFY(parentSaver->saveCalled());
 
277
    QVERIFY(directChild1->saveCalled());
 
278
    QVERIFY(directChild2->saveCalled());
 
279
    QVERIFY(indirectChild1->saveCalled());
 
280
    QVERIFY(indirectChild2->saveCalled());
 
281
    QVERIFY(indirectChild3->saveCalled());
 
282
    QVERIFY(indirectStatelessChild->saveCalled());
 
283
 
 
284
    const unsigned int desiredCalls = 1;
 
285
    QCOMPARE(parentSaver->numSaveCalls(), desiredCalls);
 
286
    QCOMPARE(directChild1->numSaveCalls(), desiredCalls);
 
287
    QCOMPARE(directChild2->numSaveCalls(), desiredCalls);
 
288
    QCOMPARE(indirectChild1->numSaveCalls(), desiredCalls);
 
289
    QCOMPARE(indirectChild2->numSaveCalls(), desiredCalls);
 
290
    QCOMPARE(indirectChild3->numSaveCalls(), desiredCalls);
 
291
    QCOMPARE(indirectStatelessChild->numSaveCalls(), desiredCalls);
 
292
 
 
293
    QCOMPARE(directChild1->getStateSavingDepth(), StateSavingObject::RECURSIVE);
 
294
 
 
295
    delete parentSaver;
 
296
 
 
297
}