← Back to branch summary

~ubuntu-branches/ubuntu/trusty/kdepimlibs/trusty

« back to all changes in this revision

Viewing changes to akonadi/calendar/tests/historytest.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg, Rohan Garg, Philip Muškovac
  • Date: 2013-11-23 17:36:44 UTC
  • mfrom: (1.1.102)
  • Revision ID: package-import@ubuntu.com-20131123173644-p5ow94192ezsny8g
Tags: 4:4.11.80-0ubuntu1
[ Rohan Garg ]
* New upstream beta release
  - Bump akonadi requirement to 1.10.45
  - Update install files
  - Update symbols

[ Philip Muškovac ]
* kdepimlibs-dev/-dbg breaks/replaces kdepim-runtime/-dbg (<< 4:4.11.80)

Show diffs side-by-side

added added

removed removed

Lines of Context:
akonadi/calendar/tests/historytest.cpp
17
17
    02110-1301, USA.
18
18
*/
19
19
 
20
 
#include "../history.h"
21
 
#include "../incidencechanger.h"
 
20
#include "historytest.h"
 
21
#include "helper.h"
22
22
 
23
23
#include <akonadi/itemfetchjob.h>
24
24
#include <akonadi/itemcreatejob.h>
25
25
#include <akonadi/collectionfetchjob.h>
26
26
#include <akonadi/collectionfetchscope.h>
 
27
#include <akonadi/itemfetchscope.h>
27
28
#include <akonadi/qtest_akonadi.h>
28
 
#include <akonadi/itemfetchscope.h>
29
 
 
30
29
#include <kcalcore/event.h>
31
30
 
32
31
#include <QTestEventLoop>
34
33
using namespace Akonadi;
35
34
using namespace KCalCore;
36
35
 
37
 
enum SignalType {
38
 
  DeletionSignal,
39
 
  CreationSignal,
40
 
  ModificationSignal,
41
 
  UndoSignal,
42
 
  RedoSignal,
43
 
  NumSignals
44
 
};
45
 
 
46
 
Q_DECLARE_METATYPE( QList<Akonadi::IncidenceChanger::ChangeType> )
47
 
 
48
 
static bool confirmExists( const Akonadi::Item &item )
49
 
{
50
 
  ItemFetchJob *job = new ItemFetchJob( item );
51
 
  return job->exec() != 0;
52
 
}
53
 
 
54
 
static bool confirmDoesntExists( const Akonadi::Item &item )
55
 
{
56
 
  ItemFetchJob *job = new ItemFetchJob( item );
57
 
  return job->exec() == 0;
58
 
}
59
 
 
60
 
static bool checkSummary( const Akonadi::Item &item, const QString &expected )
61
 
{
62
 
  ItemFetchJob *job = new ItemFetchJob( item );
63
 
  job->fetchScope().fetchFullPayload();
64
 
  Q_ASSERT( job->exec() );
65
 
  Q_ASSERT( !job->items().isEmpty() );
66
 
  Item it = job->items().first();
67
 
  Q_ASSERT( it.hasPayload() );
68
 
 
69
 
  if ( it.payload<KCalCore::Incidence::Ptr>()->summary() == expected ) {
70
 
    return true;
71
 
  } else {
72
 
      qDebug() << "Got " << it.payload<KCalCore::Incidence::Ptr>()->summary()
73
 
               << "Expected " << expected;
74
 
      return false;
75
 
  }
 
36
Q_DECLARE_METATYPE(QList<Akonadi::IncidenceChanger::ChangeType>)
 
37
 
 
38
 
 
39
static bool checkSummary(const Akonadi::Item &item, const QString &expected)
 
40
{
 
41
    ItemFetchJob *job = new ItemFetchJob(item);
 
42
    job->fetchScope().fetchFullPayload();
 
43
    Q_ASSERT(job->exec());
 
44
    Q_ASSERT(!job->items().isEmpty());
 
45
    Item it = job->items().first();
 
46
    Q_ASSERT(it.hasPayload());
 
47
 
 
48
    if (it.payload<KCalCore::Incidence::Ptr>()->summary() == expected) {
 
49
        return true;
 
50
    } else {
 
51
        qDebug() << "Got " << it.payload<KCalCore::Incidence::Ptr>()->summary()
 
52
                 << "Expected " << expected;
 
53
        return false;
 
54
    }
76
55
}
77
56
 
78
57
static Akonadi::Item item()
79
58
{
80
 
  Item item;
81
 
  Incidence::Ptr incidence = Incidence::Ptr( new Event() );
82
 
  incidence->setSummary( QLatin1String( "random summary" ) );
83
 
  item.setMimeType( incidence->mimeType() );
84
 
  item.setPayload<KCalCore::Incidence::Ptr>( incidence );
85
 
  return item;
86
 
}
87
 
 
88
 
static Akonadi::Item createItem( const Akonadi::Collection &collection )
89
 
{
90
 
  Item i = item();
91
 
  ItemCreateJob *createJob = new ItemCreateJob( i, collection );
92
 
 
93
 
  Q_ASSERT( createJob->exec() );
94
 
  Q_ASSERT( createJob->item().isValid() );
95
 
  return createJob->item();
96
 
}
97
 
 
98
 
class HistoryTest : public QObject
99
 
{
100
 
  Q_OBJECT
101
 
    Collection mCollection;
102
 
    IncidenceChanger *mChanger;
103
 
    History *mHistory;
104
 
    QHash<SignalType, int> mPendingSignals;
105
 
    QHash<int, Akonadi::Item> mItemByChangeId;
106
 
    QList<int> mKnownChangeIds;
107
 
 
108
 
    void createIncidence( const QString &uid )
109
 
    {
110
 
      Item item;
111
 
      item.setMimeType( Event::eventMimeType() );
112
 
      Incidence::Ptr incidence = Incidence::Ptr( new Event() );
113
 
      incidence->setUid( uid );
114
 
      incidence->setSummary( QLatin1String( "summary" ) );
115
 
      item.setPayload<KCalCore::Incidence::Ptr>( incidence );
116
 
      ItemCreateJob *job = new ItemCreateJob( item, mCollection, this );
117
 
      AKVERIFYEXEC( job );
118
 
    }
119
 
 
120
 
    static Akonadi::Item item()
121
 
    {
122
 
      Item item;
123
 
      Incidence::Ptr incidence = Incidence::Ptr( new Event() );
124
 
      incidence->setSummary( QLatin1String( "some summary" ) );
125
 
      item.setMimeType( incidence->mimeType() );
126
 
      item.setPayload<KCalCore::Incidence::Ptr>( incidence );
127
 
      return item;
128
 
    }
129
 
 
130
 
    void fetchCollection()
131
 
    {
132
 
      CollectionFetchJob *job = new CollectionFetchJob( Collection::root(),
133
 
                                                        CollectionFetchJob::Recursive,
134
 
                                                        this );
135
 
      // Get list of collections
136
 
      job->fetchScope().setContentMimeTypes( QStringList()
137
 
                                   << QLatin1String( "application/x-vnd.akonadi.calendar.event" ) );
138
 
      AKVERIFYEXEC( job );
139
 
 
140
 
      // Find our collection
141
 
      Collection::List collections = job->collections();
142
 
      QVERIFY( !collections.isEmpty() );
143
 
      mCollection = collections.first();
144
 
 
145
 
      QVERIFY( mCollection.isValid() );
146
 
    }
147
 
private Q_SLOTS:
148
 
    void initTestCase()
149
 
    {
150
 
      fetchCollection();
151
 
      qRegisterMetaType<Akonadi::Item>("Akonadi::Item");
152
 
      qRegisterMetaType<QList<Akonadi::IncidenceChanger::ChangeType> >( "QList<Akonadi::IncidenceChanger::ChangeType>" );
153
 
      qRegisterMetaType<QVector<Akonadi::Item::Id> >( "QVector<Akonadi::Item::Id>" );
154
 
      mChanger = new IncidenceChanger( this );
155
 
      mChanger->setShowDialogsOnError( false );
156
 
      mChanger->setHistoryEnabled( true );
157
 
      mHistory = mChanger->history();
158
 
      mChanger->setDefaultCollection( mCollection );
159
 
      connect( mChanger,
160
 
               SIGNAL(createFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
161
 
               SLOT(createFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)) );
162
 
 
163
 
      connect( mChanger,
164
 
               SIGNAL(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)),
165
 
               SLOT(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)) );
166
 
 
167
 
      connect( mChanger,
168
 
               SIGNAL(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
169
 
               SLOT(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)) );
170
 
 
171
 
      connect( mHistory, SIGNAL(undone(Akonadi::History::ResultCode)),
172
 
               SLOT(handleUndone(Akonadi::History::ResultCode)));
173
 
 
174
 
      connect( mHistory, SIGNAL(redone(Akonadi::History::ResultCode)),
175
 
               SLOT(handleRedone(Akonadi::History::ResultCode)));
176
 
    }
177
 
 
178
 
    void testCreation_data()
179
 
    {
180
 
      QTest::addColumn<Akonadi::Item>( "item" );
181
 
      QTest::newRow("item1") << item();
182
 
    }
183
 
 
184
 
    void testCreation()
185
 
    {
186
 
      QFETCH( Akonadi::Item, item );
187
 
      mPendingSignals[CreationSignal] = 1;
188
 
      QCOMPARE( mHistory->redoCount(), 0 );
189
 
      QCOMPARE( mHistory->undoCount(), 0 );
190
 
      QVERIFY( item.hasPayload() );
191
 
      const int changeId = mChanger->createIncidence( item.payload<KCalCore::Incidence::Ptr>() );
192
 
      QVERIFY( changeId > 0 );
193
 
      mKnownChangeIds << changeId;
194
 
      waitForSignals();
195
 
 
196
 
      // Check that it was created
197
 
      QVERIFY( confirmExists( mItemByChangeId.value( changeId ) ) );
198
 
 
199
 
      QCOMPARE( mHistory->redoCount(), 0 );
200
 
      QCOMPARE( mHistory->undoCount(), 1 );
201
 
 
202
 
      //undo it
203
 
      mPendingSignals[UndoSignal] = 1;
204
 
      mHistory->undo();
205
 
      waitForSignals();
206
 
 
207
 
      // Check that it doesn't exist anymore
208
 
      QVERIFY( confirmDoesntExists( mItemByChangeId.value( changeId ) ) );
209
 
 
210
 
      QCOMPARE( mHistory->redoCount(), 1 );
211
 
      QCOMPARE( mHistory->undoCount(), 0 );
212
 
 
213
 
      mPendingSignals[RedoSignal] = 1;
214
 
      mHistory->redo();
215
 
      waitForSignals();
216
 
 
217
 
      // Undo again just for fun
218
 
      mPendingSignals[UndoSignal] = 1;
219
 
      mHistory->undo();
220
 
      waitForSignals();
221
 
 
222
 
      mHistory->clear();
223
 
      QCOMPARE( mHistory->redoCount(), 0 );
224
 
      QCOMPARE( mHistory->undoCount(), 0 );
225
 
    }
226
 
 
227
 
    void testDeletion_data()
228
 
    {
229
 
      QTest::addColumn<Akonadi::Item::List>( "items" );
230
 
      Akonadi::Item::List items;
231
 
      items << createItem( mCollection );
232
 
      QTest::newRow("one item") << items;
233
 
 
234
 
      items.clear();
235
 
      items << createItem( mCollection ) << createItem( mCollection );
236
 
      QTest::newRow("two items") << items;
237
 
 
238
 
      items.clear();
239
 
      items << createItem( mCollection ) << createItem( mCollection ) << createItem( mCollection )
240
 
            << createItem( mCollection );
241
 
      QTest::newRow("four items") << items;
242
 
    }
243
 
 
244
 
    void testDeletion()
245
 
    {
246
 
      QFETCH( Akonadi::Item::List, items );
247
 
      mPendingSignals[DeletionSignal] = 1;
248
 
      QCOMPARE( mHistory->redoCount(), 0 );
249
 
      QCOMPARE( mHistory->undoCount(), 0 );
250
 
 
251
 
      const int changeId = ( items.count() == 1 ) ? mChanger->deleteIncidence( items.first() ) :
252
 
                                                    mChanger->deleteIncidences( items );
253
 
      QVERIFY( changeId > 0 );
254
 
      mKnownChangeIds << changeId;
255
 
      waitForSignals();
256
 
 
257
 
      // Check that it doesn't exist anymore
258
 
      foreach( const Akonadi::Item &item, items ) {
259
 
        QVERIFY( confirmDoesntExists( item ) );
260
 
      }
261
 
 
262
 
      mPendingSignals[UndoSignal] = 1;
263
 
      mHistory->undo();
264
 
      waitForSignals();
265
 
 
266
 
      mPendingSignals[RedoSignal] = 1;
267
 
      mHistory->redo();
268
 
      waitForSignals();
269
 
 
270
 
      mHistory->clear();
271
 
      QCOMPARE( mHistory->redoCount(), 0 );
272
 
      QCOMPARE( mHistory->undoCount(), 0 );
273
 
    }
274
 
 
275
 
    void testModification_data()
276
 
    {
277
 
      QTest::addColumn<Akonadi::Item>( "item" );
278
 
      QTest::addColumn<QString>( "oldSummary" );
279
 
      QTest::addColumn<QString>( "newSummary" );
280
 
      Item item1 = createItem( mCollection );
281
 
      const QString oldSummary( QLatin1String( "old" ) );
282
 
      const QString newSummary( QLatin1String( "new" ) );
283
 
      item1.payload<KCalCore::Incidence::Ptr>()->setSummary( oldSummary );
284
 
      QTest::newRow("item1") << item1 << oldSummary << newSummary;
285
 
    }
286
 
 
287
 
    void testModification()
288
 
    {
289
 
      QFETCH( Akonadi::Item, item );
290
 
      QFETCH( QString, oldSummary );
291
 
      QFETCH( QString, newSummary );
292
 
      QVERIFY( item.hasPayload() );
293
 
      Incidence::Ptr originalPayload = Incidence::Ptr( item.payload<KCalCore::Incidence::Ptr>()->clone() );
294
 
 
295
 
      item.payload<KCalCore::Incidence::Ptr>()->setSummary( newSummary );
296
 
      mPendingSignals[ModificationSignal] = 1;
297
 
      QCOMPARE( mHistory->redoCount(), 0 );
298
 
      QCOMPARE( mHistory->undoCount(), 0 );
299
 
 
300
 
      const int changeId = mChanger->modifyIncidence( item, originalPayload );
301
 
      QVERIFY( changeId > 0 );
302
 
      mKnownChangeIds << changeId;
303
 
      waitForSignals();
304
 
 
305
 
      QVERIFY( checkSummary( item, newSummary ) );
306
 
      QCOMPARE( mHistory->redoCount(), 0 );
307
 
      QCOMPARE( mHistory->undoCount(), 1 );
308
 
 
309
 
      mPendingSignals[UndoSignal] = 1;
310
 
      mHistory->undo();
311
 
      waitForSignals();
312
 
      QVERIFY( checkSummary( item, oldSummary ) );
313
 
      QCOMPARE( mHistory->redoCount(), 1 );
314
 
      QCOMPARE( mHistory->undoCount(), 0 );
315
 
 
316
 
      mPendingSignals[RedoSignal] = 1;
317
 
      mHistory->redo();
318
 
      waitForSignals();
319
 
      QVERIFY( checkSummary( item, newSummary ) );
320
 
      QCOMPARE( mHistory->redoCount(), 0 );
321
 
      QCOMPARE( mHistory->undoCount(), 1 );
322
 
 
323
 
      mHistory->clear();
324
 
      QCOMPARE( mHistory->redoCount(), 0 );
325
 
      QCOMPARE( mHistory->undoCount(), 0 );
326
 
 
327
 
      // Test that it isn't recorded to history when history is disabled
328
 
      mChanger->setHistoryEnabled( false );
329
 
      const int changeId2 = mChanger->modifyIncidence( item, originalPayload );
330
 
      mChanger->setHistoryEnabled( true );
331
 
      QVERIFY( changeId > 0 );
332
 
      mKnownChangeIds << changeId2;
333
 
      waitForSignals();
334
 
      QCOMPARE( mHistory->redoCount(), 0 );
335
 
      QCOMPARE( mHistory->undoCount(), 0 );
336
 
    }
337
 
 
338
 
    void testAtomicOperations_data()
339
 
    {
340
 
      QTest::addColumn<Akonadi::Item::List>( "items" );
341
 
      QTest::addColumn<QList<Akonadi::IncidenceChanger::ChangeType> >( "changeTypes" );
342
 
 
343
 
      Akonadi::Item::List items;
344
 
      QList<Akonadi::IncidenceChanger::ChangeType> changeTypes;
345
 
      //------------------------------------------------------------------------------------------
346
 
      // Create two incidences, should succeed
347
 
      items << item() << item() ;
348
 
      changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeCreate;
349
 
 
350
 
      QTest::newRow( "create two - success " ) << items << changeTypes;
351
 
      //------------------------------------------------------------------------------------------
352
 
      changeTypes.clear();
353
 
      changeTypes << IncidenceChanger::ChangeTypeModify << IncidenceChanger::ChangeTypeModify;
354
 
      items.clear();
355
 
      items << createItem( mCollection ) << createItem( mCollection );
356
 
 
357
 
      QTest::newRow( "modify two - success " ) << items << changeTypes;
358
 
      //------------------------------------------------------------------------------------------
359
 
      changeTypes.clear();
360
 
      changeTypes << IncidenceChanger::ChangeTypeDelete << IncidenceChanger::ChangeTypeDelete;
361
 
      QTest::newRow( "delete two - success " ) << items << changeTypes;
362
 
    }
363
 
 
364
 
    void testAtomicOperations()
365
 
    {
366
 
      mHistory->clear();
367
 
      QFETCH( Akonadi::Item::List, items );
368
 
      QFETCH( QList<Akonadi::IncidenceChanger::ChangeType>, changeTypes );
369
 
      mChanger->setDefaultCollection( mCollection );
370
 
      mChanger->setRespectsCollectionRights( false );
371
 
      mChanger->setDestinationPolicy( IncidenceChanger::DestinationPolicyNeverAsk );
372
 
      mChanger->startAtomicOperation();
373
 
 
374
 
      for( int i=0; i<items.count(); ++i ) {
 
59
    Item item;
 
60
    Incidence::Ptr incidence = Incidence::Ptr(new Event());
 
61
    incidence->setSummary(QLatin1String("random summary"));
 
62
    item.setMimeType(incidence->mimeType());
 
63
    item.setPayload<KCalCore::Incidence::Ptr>(incidence);
 
64
    return item;
 
65
}
 
66
 
 
67
static Akonadi::Item createItem(const Akonadi::Collection &collection)
 
68
{
 
69
    Item i = item();
 
70
    ItemCreateJob *createJob = new ItemCreateJob(i, collection);
 
71
 
 
72
    Q_ASSERT(createJob->exec());
 
73
    Q_ASSERT(createJob->item().isValid());
 
74
    return createJob->item();
 
75
}
 
76
 
 
77
void HistoryTest::initTestCase()
 
78
{
 
79
    AkonadiTest::checkTestIsIsolated();
 
80
 
 
81
    mHistory = mChanger->history();
 
82
 
 
83
    connect(mChanger,
 
84
             SIGNAL(createFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
 
85
             SLOT(createFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)));
 
86
 
 
87
    connect(mChanger,
 
88
             SIGNAL(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)),
 
89
             SLOT(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)));
 
90
 
 
91
    connect(mChanger,
 
92
             SIGNAL(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
 
93
             SLOT(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)));
 
94
 
 
95
    connect(mHistory, SIGNAL(undone(Akonadi::History::ResultCode)),
 
96
             SLOT(handleUndone(Akonadi::History::ResultCode)));
 
97
 
 
98
    connect(mHistory, SIGNAL(redone(Akonadi::History::ResultCode)),
 
99
             SLOT(handleRedone(Akonadi::History::ResultCode)));
 
100
}
 
101
 
 
102
void HistoryTest::testCreation_data()
 
103
{
 
104
    QTest::addColumn<Akonadi::Item>("item");
 
105
    QTest::newRow("item1") << item();
 
106
}
 
107
 
 
108
void HistoryTest::testCreation()
 
109
{
 
110
    QFETCH(Akonadi::Item, item);
 
111
    mPendingSignals[CreationSignal] = 1;
 
112
    QCOMPARE(mHistory->d->redoCount(), 0);
 
113
    QCOMPARE(mHistory->d->undoCount(), 0);
 
114
    QVERIFY(item.hasPayload());
 
115
    const int changeId = mChanger->createIncidence(item.payload<KCalCore::Incidence::Ptr>());
 
116
    QVERIFY(changeId > 0);
 
117
    mKnownChangeIds << changeId;
 
118
    waitForSignals();
 
119
 
 
120
    // Check that it was created
 
121
    QVERIFY(Helper::confirmExists(mItemByChangeId.value(changeId)));
 
122
 
 
123
    QCOMPARE(mHistory->d->redoCount(), 0);
 
124
    QCOMPARE(mHistory->d->undoCount(), 1);
 
125
 
 
126
    //undo it
 
127
    mPendingSignals[UndoSignal] = 1;
 
128
    mHistory->undo();
 
129
    waitForSignals();
 
130
 
 
131
    // Check that it doesn't exist anymore
 
132
    QVERIFY(Helper::confirmDoesntExist(mItemByChangeId.value(changeId)));
 
133
 
 
134
    QCOMPARE(mHistory->d->redoCount(), 1);
 
135
    QCOMPARE(mHistory->d->undoCount(), 0);
 
136
 
 
137
    mPendingSignals[RedoSignal] = 1;
 
138
    mHistory->redo();
 
139
    waitForSignals();
 
140
 
 
141
    // Undo again just for fun
 
142
    mPendingSignals[UndoSignal] = 1;
 
143
    mHistory->undo();
 
144
    waitForSignals();
 
145
 
 
146
    mHistory->clear();
 
147
    QCOMPARE(mHistory->d->redoCount(), 0);
 
148
    QCOMPARE(mHistory->d->undoCount(), 0);
 
149
}
 
150
 
 
151
void HistoryTest::testDeletion_data()
 
152
{
 
153
    QTest::addColumn<Akonadi::Item::List>("items");
 
154
    Akonadi::Item::List items;
 
155
    items << createItem(mCollection);
 
156
    QTest::newRow("one item") << items;
 
157
 
 
158
    items.clear();
 
159
    items << createItem(mCollection) << createItem(mCollection);
 
160
    QTest::newRow("two items") << items;
 
161
 
 
162
    items.clear();
 
163
    items << createItem(mCollection) << createItem(mCollection) << createItem(mCollection)
 
164
          << createItem(mCollection);
 
165
    QTest::newRow("four items") << items;
 
166
}
 
167
 
 
168
void HistoryTest::testDeletion()
 
169
{
 
170
    QFETCH(Akonadi::Item::List, items);
 
171
    mPendingSignals[DeletionSignal] = 1;
 
172
    QCOMPARE(mHistory->d->redoCount(), 0);
 
173
    QCOMPARE(mHistory->d->undoCount(), 0);
 
174
 
 
175
    const int changeId = (items.count() == 1) ? mChanger->deleteIncidence(items.first())
 
176
                                              : mChanger->deleteIncidences(items);
 
177
    QVERIFY(changeId > 0);
 
178
    mKnownChangeIds << changeId;
 
179
    waitForSignals();
 
180
 
 
181
    // Check that it doesn't exist anymore
 
182
    foreach(const Akonadi::Item &item, items) {
 
183
        QVERIFY(Helper::confirmDoesntExist(item));
 
184
    }
 
185
 
 
186
    mPendingSignals[UndoSignal] = 1;
 
187
    mHistory->undo();
 
188
    waitForSignals();
 
189
 
 
190
    mPendingSignals[RedoSignal] = 1;
 
191
    mHistory->redo();
 
192
    waitForSignals();
 
193
 
 
194
    mHistory->clear();
 
195
    QCOMPARE(mHistory->d->redoCount(), 0);
 
196
    QCOMPARE(mHistory->d->undoCount(), 0);
 
197
}
 
198
 
 
199
void HistoryTest::testModification_data()
 
200
{
 
201
    QTest::addColumn<Akonadi::Item>("item");
 
202
    QTest::addColumn<QString>("oldSummary");
 
203
    QTest::addColumn<QString>("newSummary");
 
204
    Item item1 = createItem(mCollection);
 
205
    const QString oldSummary(QLatin1String("old"));
 
206
    const QString newSummary(QLatin1String("new"));
 
207
    item1.payload<KCalCore::Incidence::Ptr>()->setSummary(oldSummary);
 
208
    QTest::newRow("item1") << item1 << oldSummary << newSummary;
 
209
}
 
210
 
 
211
void HistoryTest::testModification()
 
212
{
 
213
    QFETCH(Akonadi::Item, item);
 
214
    QFETCH(QString, oldSummary);
 
215
    QFETCH(QString, newSummary);
 
216
    QVERIFY(item.hasPayload());
 
217
    Incidence::Ptr originalPayload = Incidence::Ptr(item.payload<KCalCore::Incidence::Ptr>()->clone());
 
218
 
 
219
    item.payload<KCalCore::Incidence::Ptr>()->setSummary(newSummary);
 
220
    mPendingSignals[ModificationSignal] = 1;
 
221
    QCOMPARE(mHistory->d->redoCount(), 0);
 
222
    QCOMPARE(mHistory->d->undoCount(), 0);
 
223
 
 
224
    const int changeId = mChanger->modifyIncidence(item, originalPayload);
 
225
    QVERIFY(changeId > 0);
 
226
    mKnownChangeIds << changeId;
 
227
    waitForSignals();
 
228
 
 
229
    QVERIFY(checkSummary(item, newSummary));
 
230
    QCOMPARE(mHistory->d->redoCount(), 0);
 
231
    QCOMPARE(mHistory->d->undoCount(), 1);
 
232
 
 
233
    mPendingSignals[UndoSignal] = 1;
 
234
    mHistory->undo();
 
235
    waitForSignals();
 
236
    QVERIFY(checkSummary(item, oldSummary));
 
237
    QCOMPARE(mHistory->d->redoCount(), 1);
 
238
    QCOMPARE(mHistory->d->undoCount(), 0);
 
239
 
 
240
    mPendingSignals[RedoSignal] = 1;
 
241
    mHistory->redo();
 
242
    waitForSignals();
 
243
    QVERIFY(checkSummary(item, newSummary));
 
244
    QCOMPARE(mHistory->d->redoCount(), 0);
 
245
    QCOMPARE(mHistory->d->undoCount(), 1);
 
246
 
 
247
    mHistory->clear();
 
248
    QCOMPARE(mHistory->d->redoCount(), 0);
 
249
    QCOMPARE(mHistory->d->undoCount(), 0);
 
250
 
 
251
    // Test that it isn't recorded to history when history is disabled
 
252
    mChanger->setHistoryEnabled(false);
 
253
    mPendingSignals[ModificationSignal] = 1;
 
254
    const int changeId2 = mChanger->modifyIncidence(item, originalPayload);
 
255
    mChanger->setHistoryEnabled(true);
 
256
    QVERIFY(changeId > 0);
 
257
    mKnownChangeIds << changeId2;
 
258
    waitForSignals();
 
259
    QCOMPARE(mHistory->d->redoCount(), 0);
 
260
    QCOMPARE(mHistory->d->undoCount(), 0);
 
261
}
 
262
 
 
263
void HistoryTest::testAtomicOperations_data()
 
264
{
 
265
    QTest::addColumn<Akonadi::Item::List>("items");
 
266
    QTest::addColumn<QList<Akonadi::IncidenceChanger::ChangeType> >("changeTypes");
 
267
 
 
268
    Akonadi::Item::List items;
 
269
    QList<Akonadi::IncidenceChanger::ChangeType> changeTypes;
 
270
    //------------------------------------------------------------------------------------------
 
271
    // Create two incidences, should succeed
 
272
    items << item() << item();
 
273
    changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeCreate;
 
274
 
 
275
    QTest::newRow("create two - success ") << items << changeTypes;
 
276
    //------------------------------------------------------------------------------------------
 
277
    changeTypes.clear();
 
278
    changeTypes << IncidenceChanger::ChangeTypeModify << IncidenceChanger::ChangeTypeModify;
 
279
    items.clear();
 
280
    items << createItem(mCollection) << createItem(mCollection);
 
281
 
 
282
    QTest::newRow("modify two - success ") << items << changeTypes;
 
283
    //------------------------------------------------------------------------------------------
 
284
    changeTypes.clear();
 
285
    changeTypes << IncidenceChanger::ChangeTypeDelete << IncidenceChanger::ChangeTypeDelete;
 
286
    QTest::newRow("delete two - success ") << items << changeTypes;
 
287
}
 
288
 
 
289
void HistoryTest::testAtomicOperations()
 
290
{
 
291
    mHistory->clear();
 
292
    QFETCH(Akonadi::Item::List, items);
 
293
    QFETCH(QList<Akonadi::IncidenceChanger::ChangeType>, changeTypes);
 
294
    mChanger->setDefaultCollection(mCollection);
 
295
    mChanger->setRespectsCollectionRights(false);
 
296
    mChanger->setDestinationPolicy(IncidenceChanger::DestinationPolicyNeverAsk);
 
297
    mChanger->startAtomicOperation();
 
298
 
 
299
    for (int i=0; i<items.count(); ++i) {
375
300
        const Akonadi::Item item = items[i];
376
301
        int changeId = -1;
377
 
        switch( changeTypes[i] ) {
378
 
          case IncidenceChanger::ChangeTypeCreate:
379
 
            changeId = mChanger->createIncidence( item.hasPayload()                           ?
380
 
                                                    item.payload<KCalCore::Incidence::Ptr>()  :
381
 
                                                    Incidence::Ptr() );
382
 
            QVERIFY( changeId != -1 );
 
302
        switch(changeTypes[i]) {
 
303
        case IncidenceChanger::ChangeTypeCreate:
 
304
            changeId = mChanger->createIncidence(item.hasPayload() ? item.payload<KCalCore::Incidence::Ptr>()
 
305
                                                                   : Incidence::Ptr());
 
306
            QVERIFY(changeId != -1);
383
307
            mKnownChangeIds << changeId;
384
308
            ++mPendingSignals[CreationSignal];
385
 
          break;
386
 
          case IncidenceChanger::ChangeTypeDelete:
387
 
            changeId = mChanger->deleteIncidence( item );
388
 
            QVERIFY( changeId != -1 );
 
309
            break;
 
310
        case IncidenceChanger::ChangeTypeDelete:
 
311
            changeId = mChanger->deleteIncidence(item);
 
312
            QVERIFY(changeId != -1);
389
313
            mKnownChangeIds << changeId;
390
314
            ++mPendingSignals[DeletionSignal];
391
 
          break;
392
 
          case IncidenceChanger::ChangeTypeModify:
393
 
          {
394
 
            QVERIFY( item.isValid() );
395
 
            QVERIFY( item.hasPayload<KCalCore::Incidence::Ptr>() );
396
 
            Incidence::Ptr originalPayload = Incidence::Ptr( item.payload<KCalCore::Incidence::Ptr>()->clone() );
397
 
            item.payload<KCalCore::Incidence::Ptr>()->setSummary( QLatin1String( "Changed" ) );
398
 
            changeId = mChanger->modifyIncidence( item, originalPayload );
399
 
            QVERIFY( changeId != -1 );
 
315
            break;
 
316
        case IncidenceChanger::ChangeTypeModify:
 
317
        {
 
318
            QVERIFY(item.isValid());
 
319
            QVERIFY(item.hasPayload<KCalCore::Incidence::Ptr>());
 
320
            Incidence::Ptr originalPayload = Incidence::Ptr(item.payload<KCalCore::Incidence::Ptr>()->clone());
 
321
            item.payload<KCalCore::Incidence::Ptr>()->setSummary(QLatin1String("Changed"));
 
322
            changeId = mChanger->modifyIncidence(item, originalPayload);
 
323
            QVERIFY(changeId != -1);
400
324
            mKnownChangeIds << changeId;
401
325
            ++mPendingSignals[ModificationSignal];
402
 
          }
403
 
          break;
404
 
          default:
405
 
            QVERIFY( false );
406
 
        }
407
 
      }
408
 
 
409
 
      mChanger->endAtomicOperation();
410
 
      waitForSignals();
411
 
 
412
 
      QCOMPARE( mHistory->undoCount(), 1 );
413
 
      QCOMPARE( mHistory->redoCount(), 0 );
414
 
 
415
 
      mPendingSignals[UndoSignal] = 1;
416
 
      mHistory->undo();
417
 
      waitForSignals();
418
 
      QCOMPARE( mHistory->undoCount(), 0 );
419
 
      QCOMPARE( mHistory->redoCount(), 1 );
420
 
 
421
 
      // Verify that it got undone
422
 
      for( int i=0; i<items.count(); ++i ) {
 
326
        }
 
327
            break;
 
328
        default:
 
329
            QVERIFY(false);
 
330
        }
 
331
    }
 
332
 
 
333
    mChanger->endAtomicOperation();
 
334
    waitForSignals();
 
335
 
 
336
    QCOMPARE(mHistory->d->undoCount(), 1);
 
337
    QCOMPARE(mHistory->d->redoCount(), 0);
 
338
 
 
339
    mPendingSignals[UndoSignal] = 1;
 
340
    mHistory->undo();
 
341
    waitForSignals();
 
342
    QCOMPARE(mHistory->d->undoCount(), 0);
 
343
    QCOMPARE(mHistory->d->redoCount(), 1);
 
344
 
 
345
    // Verify that it got undone
 
346
    for (int i=0; i<items.count(); ++i) {
423
347
        const Akonadi::Item item = items[i];
424
 
        switch( changeTypes[i] ) {
425
 
          case IncidenceChanger::ChangeTypeCreate:
 
348
        switch(changeTypes[i]) {
 
349
        case IncidenceChanger::ChangeTypeCreate:
426
350
            // It changed id, have no way to verify
427
 
          break;
428
 
          case IncidenceChanger::ChangeTypeDelete:
429
 
            QVERIFY( confirmDoesntExists( item ) );
430
 
          break;
431
 
          case IncidenceChanger::ChangeTypeModify:
432
 
            QVERIFY( checkSummary( item, QLatin1String( "random summary" ) ) );
433
 
          break;
434
 
          default:
435
 
            QVERIFY( false );
436
 
        }
437
 
      }
438
 
 
439
 
      mPendingSignals[RedoSignal] = 1;
440
 
      mHistory->redo();
441
 
      waitForSignals();
442
 
      QCOMPARE( mHistory->undoCount(), 1 );
443
 
      QCOMPARE( mHistory->redoCount(), 0 );
444
 
 
445
 
      mPendingSignals[UndoSignal] = 1;
446
 
      mHistory->undo();
447
 
      waitForSignals();
448
 
      QCOMPARE( mHistory->undoCount(), 0 );
449
 
      QCOMPARE( mHistory->redoCount(), 1 );
450
 
 
451
 
      mHistory->clear();
452
 
      QCOMPARE( mHistory->redoCount(), 0 );
453
 
      QCOMPARE( mHistory->undoCount(), 0 );
454
 
    }
455
 
 
456
 
private:
457
 
    void waitForSignals()
458
 
    {
459
 
      bool somethingToWaitFor = false;
460
 
      for ( int i=0; i<NumSignals; ++i ) {
461
 
        if ( mPendingSignals.value( static_cast<SignalType>(i) ) ) {
462
 
          somethingToWaitFor = true;
463
 
          break;
464
 
        }
465
 
      }
466
 
 
467
 
      if ( !somethingToWaitFor )
468
 
        return;
469
 
 
470
 
      QTestEventLoop::instance().enterLoop( 10 );
471
 
 
472
 
      if ( QTestEventLoop::instance().timeout() ) {
473
 
        for ( int i=0; i<NumSignals; ++i ) {
474
 
          qDebug() << mPendingSignals.value( static_cast<SignalType>(i) );
475
 
        }
476
 
      }
477
 
 
478
 
      QVERIFY( !QTestEventLoop::instance().timeout() );
479
 
    }
480
 
 
481
 
public Q_SLOTS:
482
 
    void deleteFinished( int changeId,
483
 
                         const QVector<Akonadi::Item::Id> &deletedIds,
484
 
                         Akonadi::IncidenceChanger::ResultCode resultCode,
485
 
                         const QString &errorMessage )
486
 
    {
487
 
      QVERIFY( changeId != -1 );
488
 
 
489
 
      if ( !mKnownChangeIds.contains(changeId) )
490
 
        return;
491
 
 
492
 
      --mPendingSignals[DeletionSignal];
493
 
 
494
 
      if ( resultCode != IncidenceChanger::ResultCodeSuccess ) {
 
351
            break;
 
352
        case IncidenceChanger::ChangeTypeDelete:
 
353
            QVERIFY(Helper::confirmDoesntExist(item));
 
354
            break;
 
355
        case IncidenceChanger::ChangeTypeModify:
 
356
            QVERIFY(checkSummary(item, QLatin1String("random summary")));
 
357
            break;
 
358
        default:
 
359
            QVERIFY(false);
 
360
        }
 
361
    }
 
362
 
 
363
    mPendingSignals[RedoSignal] = 1;
 
364
    mHistory->redo();
 
365
    waitForSignals();
 
366
    QCOMPARE(mHistory->d->undoCount(), 1);
 
367
    QCOMPARE(mHistory->d->redoCount(), 0);
 
368
 
 
369
    mPendingSignals[UndoSignal] = 1;
 
370
    mHistory->undo();
 
371
    waitForSignals();
 
372
    QCOMPARE(mHistory->d->undoCount(), 0);
 
373
    QCOMPARE(mHistory->d->redoCount(), 1);
 
374
 
 
375
    mHistory->clear();
 
376
    QCOMPARE(mHistory->d->redoCount(), 0);
 
377
    QCOMPARE(mHistory->d->undoCount(), 0);
 
378
}
 
379
 
 
380
 
 
381
// Tests a sequence of various create/delete/modify operations
 
382
void HistoryTest::testMix_data()
 
383
{
 
384
    QTest::addColumn<Akonadi::Item::List>("items");
 
385
    QTest::addColumn<QList<Akonadi::IncidenceChanger::ChangeType> >("changeTypes");
 
386
 
 
387
    Akonadi::Item::List items;
 
388
    QList<Akonadi::IncidenceChanger::ChangeType> changeTypes;
 
389
    //------------------------------------------------------------------------------------------
 
390
    // Create two incidences
 
391
    items.clear();
 
392
    items << item() << item();
 
393
    changeTypes.clear();
 
394
    changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeCreate;
 
395
    QTest::newRow("create two - success ") << items << changeTypes;
 
396
    //------------------------------------------------------------------------------------------
 
397
    // Create one, then delete it
 
398
    Akonadi::Item i = item();
 
399
    items.clear();
 
400
    items << i << i;
 
401
    changeTypes.clear();
 
402
    changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeDelete;
 
403
    QTest::newRow("create then delete") << items << changeTypes;
 
404
    //------------------------------------------------------------------------------------------
 
405
    // Create one, then modify it, then delete it
 
406
    i = item();
 
407
    items.clear();
 
408
    items << i << i << i;
 
409
    changeTypes.clear();
 
410
    changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeModify << IncidenceChanger::ChangeTypeDelete;
 
411
    QTest::newRow("create then modify then deelte") << items << changeTypes;
 
412
}
 
413
 
 
414
void HistoryTest::testMix()
 
415
{
 
416
    QFETCH(Akonadi::Item::List, items);
 
417
    QFETCH(QList<Akonadi::IncidenceChanger::ChangeType>, changeTypes);
 
418
    int lastCreateChangeId = -1;
 
419
    mHistory->clear();
 
420
    mChanger->setDefaultCollection(mCollection);
 
421
    mChanger->setRespectsCollectionRights(false);
 
422
    mChanger->setDestinationPolicy(IncidenceChanger::DestinationPolicyNeverAsk);
 
423
 
 
424
    for (int i=0; i<items.count(); ++i) {
 
425
        Akonadi::Item item = items[i];
 
426
        int changeId = -1;
 
427
        switch (changeTypes[i]) {
 
428
        case IncidenceChanger::ChangeTypeCreate:
 
429
            lastCreateChangeId = mChanger->createIncidence(item.payload<KCalCore::Incidence::Ptr>());
 
430
            QVERIFY(lastCreateChangeId != -1);
 
431
            mKnownChangeIds << lastCreateChangeId;
 
432
            ++mPendingSignals[CreationSignal];
 
433
            waitForSignals();
 
434
            break;
 
435
        case IncidenceChanger::ChangeTypeDelete:
 
436
            item = item.isValid() ? item : mItemByChangeId.value(lastCreateChangeId);
 
437
            QVERIFY(item.isValid());
 
438
            changeId = mChanger->deleteIncidence(item);
 
439
            QVERIFY(changeId != -1);
 
440
            mKnownChangeIds << changeId;
 
441
            ++mPendingSignals[DeletionSignal];
 
442
            waitForSignals();
 
443
            break;
 
444
        case IncidenceChanger::ChangeTypeModify:
 
445
        {
 
446
            item = item.isValid() ? item : mItemByChangeId.value(lastCreateChangeId);
 
447
            QVERIFY(item.isValid());
 
448
            QVERIFY(item.hasPayload<KCalCore::Incidence::Ptr>());
 
449
            Incidence::Ptr originalPayload = Incidence::Ptr(item.payload<KCalCore::Incidence::Ptr>()->clone());
 
450
            item.payload<KCalCore::Incidence::Ptr>()->setSummary(QLatin1String("Changed"));
 
451
            QVERIFY(originalPayload);
 
452
            changeId = mChanger->modifyIncidence(item, originalPayload);
 
453
            QVERIFY(changeId != -1);
 
454
            mKnownChangeIds << changeId;
 
455
            ++mPendingSignals[ModificationSignal];
 
456
            waitForSignals();
 
457
        }
 
458
            break;
 
459
        default:
 
460
            QVERIFY(false);
 
461
        }
 
462
 
 
463
    }
 
464
 
 
465
    QCOMPARE(mHistory->d->undoCount(), changeTypes.count());
 
466
 
 
467
    // All operations are done, now undo them:
 
468
    for (int i=0; i<changeTypes.count(); i++) {
 
469
        QCOMPARE(mHistory->d->undoCount(), changeTypes.count()-i);
 
470
        QCOMPARE(mHistory->d->redoCount(), i);
 
471
        mPendingSignals[UndoSignal] = 1;
 
472
        mHistory->undo();
 
473
        waitForSignals();
 
474
    }
 
475
 
 
476
    QCOMPARE(mHistory->d->undoCount(), 0);
 
477
    QCOMPARE(mHistory->d->redoCount(), changeTypes.count());
 
478
 
 
479
    // Now redo them
 
480
    for (int i=0; i<changeTypes.count(); i++) {
 
481
        QCOMPARE(mHistory->d->undoCount(), i);
 
482
        QCOMPARE(mHistory->d->redoCount(), changeTypes.count()-i);
 
483
        mPendingSignals[RedoSignal] = 1;
 
484
        mHistory->redo();
 
485
        waitForSignals();
 
486
    }
 
487
 
 
488
    QCOMPARE(mHistory->d->undoCount(), changeTypes.count());
 
489
    QCOMPARE(mHistory->d->redoCount(), 0);
 
490
}
 
491
 
 
492
 
 
493
void HistoryTest::waitForSignals()
 
494
{
 
495
    bool somethingToWaitFor = false;
 
496
    for (int i=0; i<NumSignals; ++i) {
 
497
        if (mPendingSignals.value(static_cast<SignalType>(i))) {
 
498
            somethingToWaitFor = true;
 
499
            break;
 
500
        }
 
501
    }
 
502
 
 
503
    if (!somethingToWaitFor)
 
504
        return;
 
505
 
 
506
    QTestEventLoop::instance().enterLoop(10);
 
507
 
 
508
    if (QTestEventLoop::instance().timeout()) {
 
509
        for (int i=0; i<NumSignals; ++i) {
 
510
            qDebug() << mPendingSignals.value(static_cast<SignalType>(i));
 
511
        }
 
512
    }
 
513
 
 
514
    QVERIFY(!QTestEventLoop::instance().timeout());
 
515
}
 
516
 
 
517
 
 
518
void HistoryTest::deleteFinished(int changeId,
 
519
                                 const QVector<Akonadi::Item::Id> &deletedIds,
 
520
                                 Akonadi::IncidenceChanger::ResultCode resultCode,
 
521
                                 const QString &errorMessage)
 
522
{
 
523
    QVERIFY(changeId != -1);
 
524
 
 
525
    if (!mKnownChangeIds.contains(changeId))
 
526
        return;
 
527
 
 
528
    QVERIFY(mPendingSignals[DeletionSignal] > 0);
 
529
    --mPendingSignals[DeletionSignal];
 
530
 
 
531
    if (resultCode != IncidenceChanger::ResultCodeSuccess) {
495
532
        kDebug() << "Error string is " << errorMessage;
496
 
      } else {
497
 
        QVERIFY( !deletedIds.isEmpty() );
498
 
        foreach( Akonadi::Item::Id id , deletedIds ) {
499
 
          QVERIFY( id != -1 );
 
533
    } else {
 
534
        QVERIFY(!deletedIds.isEmpty());
 
535
        foreach(Akonadi::Item::Id id , deletedIds) {
 
536
            QVERIFY(id != -1);
500
537
        }
501
 
      }
502
 
      maybeQuitEventLoop();
503
538
    }
504
 
 
505
 
    void createFinished( int changeId,
506
 
                         const Akonadi::Item &item,
507
 
                         Akonadi::IncidenceChanger::ResultCode resultCode,
508
 
                         const QString &errorString )
509
 
    {
510
 
      QVERIFY( changeId != -1 );
511
 
 
512
 
      if ( !mKnownChangeIds.contains(changeId) )
 
539
    maybeQuitEventLoop();
 
540
}
 
541
 
 
542
void HistoryTest::createFinished(int changeId,
 
543
                                  const Akonadi::Item &item,
 
544
                                  Akonadi::IncidenceChanger::ResultCode resultCode,
 
545
                                  const QString &errorString)
 
546
{
 
547
    QVERIFY(changeId != -1);
 
548
 
 
549
    if (!mKnownChangeIds.contains(changeId))
513
550
        return;
514
551
 
515
 
      --mPendingSignals[CreationSignal];
516
 
 
517
 
      if ( resultCode == IncidenceChanger::ResultCodeSuccess ) {
518
 
        QVERIFY( item.isValid() );
519
 
        QVERIFY( item.parentCollection().isValid() );
520
 
        mItemByChangeId.insert( changeId, item );
521
 
        QVERIFY( item.hasPayload() );
 
552
    QVERIFY(mPendingSignals[CreationSignal] > 0);
 
553
 
 
554
    --mPendingSignals[CreationSignal];
 
555
 
 
556
    if (resultCode == IncidenceChanger::ResultCodeSuccess) {
 
557
        QVERIFY(item.isValid());
 
558
        QVERIFY(item.parentCollection().isValid());
 
559
        mItemByChangeId.insert(changeId, item);
 
560
        QVERIFY(item.hasPayload());
522
561
        Incidence::Ptr incidence = item.payload<KCalCore::Incidence::Ptr>();
523
 
        //mItemIdByUid.insert( incidence->uid(), item.id() );
524
 
      } else {
 
562
        //mItemIdByUid.insert(incidence->uid(), item.id());
 
563
    } else {
525
564
        kDebug() << "Error string is " << errorString;
526
 
      }
527
 
 
528
 
      maybeQuitEventLoop();
529
565
    }
530
566
 
531
 
    void modifyFinished( int changeId,
532
 
                         const Akonadi::Item &item,
533
 
                         Akonadi::IncidenceChanger::ResultCode resultCode,
534
 
                         const QString &errorString )
535
 
    {
536
 
      --mPendingSignals[ModificationSignal];
 
567
    maybeQuitEventLoop();
 
568
}
537
569
 
538
 
      if ( !mKnownChangeIds.contains(changeId) )
 
570
void HistoryTest::modifyFinished(int changeId,
 
571
                                 const Akonadi::Item &item,
 
572
                                 Akonadi::IncidenceChanger::ResultCode resultCode,
 
573
                                 const QString &errorString)
 
574
{
 
575
    if (!mKnownChangeIds.contains(changeId))
539
576
        return;
540
577
 
541
 
      QVERIFY( changeId != -1 );
542
 
 
543
 
      if ( resultCode == IncidenceChanger::ResultCodeSuccess )
544
 
        QVERIFY( item.isValid() );
545
 
      else
 
578
    QVERIFY(mPendingSignals[ModificationSignal] > 0);
 
579
    --mPendingSignals[ModificationSignal];
 
580
 
 
581
    QVERIFY(changeId != -1);
 
582
    QCOMPARE(resultCode, IncidenceChanger::ResultCodeSuccess);
 
583
 
 
584
    if (resultCode == IncidenceChanger::ResultCodeSuccess)
 
585
        QVERIFY(item.isValid());
 
586
    else
546
587
        kDebug() << "Error string is " << errorString;
547
588
 
548
 
      maybeQuitEventLoop();
549
 
    }
550
 
 
551
 
    void handleRedone( Akonadi::History::ResultCode result )
552
 
    {
553
 
      QCOMPARE( result, History::ResultCodeSuccess );
554
 
      --mPendingSignals[RedoSignal];
555
 
      maybeQuitEventLoop();
556
 
    }
557
 
 
558
 
    void handleUndone( Akonadi::History::ResultCode result )
559
 
    {
560
 
      QCOMPARE( result, History::ResultCodeSuccess );
561
 
      --mPendingSignals[UndoSignal];
562
 
      maybeQuitEventLoop();
563
 
    }
564
 
 
565
 
    void maybeQuitEventLoop()
566
 
    {
567
 
      for ( int i=0; i<NumSignals; ++i ) {
568
 
        if ( mPendingSignals.value( static_cast<SignalType>(i) ) > 0 )
569
 
          return;
570
 
      }
571
 
      QTestEventLoop::instance().exitLoop();
572
 
    }
573
 
};
574
 
 
575
 
QTEST_AKONADIMAIN( HistoryTest, GUI )
576
 
 
577
 
#include "HistoryTest.moc"
 
589
    maybeQuitEventLoop();
 
590
}
 
591
 
 
592
void HistoryTest::handleRedone(Akonadi::History::ResultCode result)
 
593
{
 
594
    QCOMPARE(result, History::ResultCodeSuccess);
 
595
    --mPendingSignals[RedoSignal];
 
596
    maybeQuitEventLoop();
 
597
}
 
598
 
 
599
void HistoryTest::handleUndone(Akonadi::History::ResultCode result)
 
600
{
 
601
    QCOMPARE(result, History::ResultCodeSuccess);
 
602
    --mPendingSignals[UndoSignal];
 
603
    maybeQuitEventLoop();
 
604
}
 
605
 
 
606
void HistoryTest::maybeQuitEventLoop()
 
607
{
 
608
    for (int i=0; i<NumSignals; ++i) {
 
609
        if (mPendingSignals.value(static_cast<SignalType>(i)) > 0)
 
610
            return;
 
611
    }
 
612
    QTestEventLoop::instance().exitLoop();
 
613
}
 
614
 
 
615
 
 
616
QTEST_AKONADIMAIN(HistoryTest, GUI)