1 /*
2     This file is part of the Okteta Core library, made within the KDE community.
3 
4     SPDX-FileCopyrightText: 2008 Friedrich W. H. Kossebau <kossebau@kde.org>
5 
6     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
7 */
8 
9 #include "revertablepiecetabletest.hpp"
10 
11 // test object
12 #include <piecetable/revertablepiecetable.hpp>
13 // Qt
14 #include <QTest>
15 
16 namespace KPieceTable {
17 
18 // local variables
19 static constexpr Address Start = 15;
20 static constexpr Address End = 27;
21 static constexpr Size HalfBaseSize = 50;
22 static constexpr Size BaseSize = 2 * HalfBaseSize;
23 
24 static constexpr Size Width = End - Start + 1;
25 
26 static constexpr Address ChangeStart = 0;
27 static constexpr Address ChangeEnd = ChangeStart + Width - 1;
28 
testSimpleConstructor()29 void RevertablePieceTableTest::testSimpleConstructor()
30 {
31     RevertablePieceTable pieceTable;
32     QCOMPARE(pieceTable.size(), 0);
33     QCOMPARE(pieceTable.changesCount(), 0);
34     QCOMPARE(pieceTable.appliedChangesCount(), 0);
35 }
36 
testInit()37 void RevertablePieceTableTest::testInit()
38 {
39     RevertablePieceTable pieceTable;
40 
41     pieceTable.init(BaseSize);
42     int storageId;
43     int storageOffset;
44 
45     QCOMPARE(pieceTable.size(), BaseSize);
46     QCOMPARE(pieceTable.changesCount(), 0);
47     QCOMPARE(pieceTable.appliedChangesCount(), 0);
48 
49     bool result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
50     QVERIFY(result);
51     QCOMPARE(storageOffset, 0);
52     QCOMPARE(storageId, (int)Piece::OriginalStorage);
53 
54     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
55     QVERIFY(result);
56     QCOMPARE(storageOffset, Start);
57     QCOMPARE(storageId, (int)Piece::OriginalStorage);
58 
59     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
60     QVERIFY(result);
61     QCOMPARE(storageOffset, End);
62     QCOMPARE(storageId, (int)Piece::OriginalStorage);
63 
64     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
65     QVERIFY(result);
66     QCOMPARE(storageOffset, BaseSize - 1);
67     QCOMPARE(storageId, (int)Piece::OriginalStorage);
68 
69     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
70     QVERIFY(!result);
71 }
72 
fillWithSize(RevertablePieceTable * pieceTable,int count)73 static void fillWithSize(RevertablePieceTable* pieceTable, int count)
74 {
75     int dummy;
76     pieceTable->init(0);
77     for (int i = 0; i < count; ++i) {
78         pieceTable->insert(0, BaseSize, &dummy);
79     }
80 }
81 
testInsert()82 void RevertablePieceTableTest::testInsert()
83 {
84     RevertablePieceTable pieceTable;
85 
86     int storageId;
87     int storageOffset;
88     bool result;
89 
90     // inserting to empty
91     pieceTable.init(0);
92     pieceTable.insert(0, Width, &storageOffset);
93 
94     QCOMPARE(pieceTable.size(), Width);
95     QCOMPARE(pieceTable.changesCount(), 1);
96     QCOMPARE(pieceTable.appliedChangesCount(), 1);
97     QCOMPARE(storageOffset, ChangeStart);
98 
99     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
100     QVERIFY(result);
101     QCOMPARE(storageOffset, ChangeStart);
102     QCOMPARE(storageId, (int)Piece::ChangeStorage);
103 
104     result = pieceTable.getStorageData(&storageId, &storageOffset, Width - 1);
105     QVERIFY(result);
106     QCOMPARE(storageOffset, ChangeEnd);
107     QCOMPARE(storageId, (int)Piece::ChangeStorage);
108 
109     result = pieceTable.getStorageData(&storageId, &storageOffset, Width);
110     QVERIFY(!result);
111 
112     // inserting one at the begin
113     pieceTable.init(BaseSize);
114     pieceTable.insert(0, Width, &storageOffset);
115 
116     QCOMPARE(pieceTable.size(), BaseSize + Width);
117     QCOMPARE(pieceTable.changesCount(), 1);
118     QCOMPARE(pieceTable.appliedChangesCount(), 1);
119     QCOMPARE(storageOffset, ChangeStart);
120 
121     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
122     QVERIFY(result);
123     QCOMPARE(storageOffset, ChangeStart);
124     QCOMPARE(storageId, (int)Piece::ChangeStorage);
125 
126     result = pieceTable.getStorageData(&storageId, &storageOffset, Width - 1);
127     QVERIFY(result);
128     QCOMPARE(storageOffset, ChangeEnd);
129     QCOMPARE(storageId, (int)Piece::ChangeStorage);
130 
131     result = pieceTable.getStorageData(&storageId, &storageOffset, Width);
132     QVERIFY(result);
133     QCOMPARE(storageOffset, 0);
134     QCOMPARE(storageId, (int)Piece::OriginalStorage);
135 
136     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width - 1);
137     QVERIFY(result);
138     QCOMPARE(storageOffset, BaseSize - 1);
139     QCOMPARE(storageId, (int)Piece::OriginalStorage);
140 
141     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width);
142     QVERIFY(!result);
143 
144     // inserting one in the middle
145     pieceTable.init(BaseSize);
146     pieceTable.insert(Start, Width, &storageOffset);
147 
148     QCOMPARE(pieceTable.size(), BaseSize + Width);
149     QCOMPARE(pieceTable.changesCount(), 1);
150     QCOMPARE(pieceTable.appliedChangesCount(), 1);
151     QCOMPARE(storageOffset, ChangeStart);
152 
153     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
154     QVERIFY(result);
155     QCOMPARE(storageOffset, Start - 1);
156     QCOMPARE(storageId, (int)Piece::OriginalStorage);
157 
158     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
159     QVERIFY(result);
160     QCOMPARE(storageOffset, ChangeStart);
161     QCOMPARE(storageId, (int)Piece::ChangeStorage);
162 
163     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
164     QVERIFY(result);
165     QCOMPARE(storageOffset, ChangeEnd);
166     QCOMPARE(storageId, (int)Piece::ChangeStorage);
167 
168     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
169     QVERIFY(result);
170     QCOMPARE(storageOffset, Start);
171     QCOMPARE(storageId, (int)Piece::OriginalStorage);
172 
173     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width - 1);
174     QVERIFY(result);
175     QCOMPARE(storageOffset, BaseSize - 1);
176     QCOMPARE(storageId, (int)Piece::OriginalStorage);
177 
178     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width);
179     QVERIFY(!result);
180 
181     // inserting one at the end
182     pieceTable.init(BaseSize);
183     pieceTable.insert(BaseSize, Width, &storageOffset);
184 
185     QCOMPARE(pieceTable.size(), BaseSize + Width);
186     QCOMPARE(pieceTable.changesCount(), 1);
187     QCOMPARE(pieceTable.appliedChangesCount(), 1);
188     QCOMPARE(storageOffset, ChangeStart);
189 
190     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
191     QVERIFY(result);
192     QCOMPARE(storageOffset, BaseSize - 1);
193     QCOMPARE(storageId, (int)Piece::OriginalStorage);
194 
195     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
196     QVERIFY(result);
197     QCOMPARE(storageOffset, ChangeStart);
198     QCOMPARE(storageId, (int)Piece::ChangeStorage);
199 
200     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width - 1);
201     QVERIFY(result);
202     QCOMPARE(storageOffset, ChangeEnd);
203     QCOMPARE(storageId, (int)Piece::ChangeStorage);
204 
205     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width);
206     QVERIFY(!result);
207 
208     // inserting a lot:
209     // inserting before, after and in another inserted section, two recursions
210     // 121110  8 7 6  4 3 2
211     // \/\/\/ \/\/\/ \/\/\/
212     //  |-9-|  |-5-|  |-1-|
213     //  \  /   \  /   \  /
214     //   \/     \/     \/
215     //    |-----0-------|
216     // TODO: do this also in forward sequences
217     pieceTable.init(BaseSize);   // 0
218     const int Mid = BaseSize / 2;
219     int changeStarts[13];
220     pieceTable.insert(BaseSize, BaseSize, &storageOffset);   // 1
221     changeStarts[1] = storageOffset;
222     pieceTable.insert(BaseSize + BaseSize, BaseSize, &storageOffset); // 2
223     changeStarts[2] = storageOffset;
224     pieceTable.insert(BaseSize + Mid, BaseSize, &storageOffset); // 3
225     changeStarts[3] = storageOffset;
226     pieceTable.insert(BaseSize, BaseSize, &storageOffset);   // 4
227     changeStarts[4] = storageOffset;
228 
229     pieceTable.insert(Mid, BaseSize, &storageOffset);   // 5
230     changeStarts[5] = storageOffset;
231     pieceTable.insert(Mid + BaseSize, BaseSize, &storageOffset); // 6
232     changeStarts[6] = storageOffset;
233     pieceTable.insert(Mid + Mid, BaseSize, &storageOffset); // 7
234     changeStarts[7] = storageOffset;
235     pieceTable.insert(Mid, BaseSize, &storageOffset);   // 8
236     changeStarts[8] = storageOffset;
237 
238     pieceTable.insert(0, BaseSize, &storageOffset);   // 9
239     changeStarts[9] = storageOffset;
240     pieceTable.insert(BaseSize, BaseSize, &storageOffset);   // 10
241     changeStarts[10] = storageOffset;
242     pieceTable.insert(Mid, BaseSize, &storageOffset);   // 11
243     changeStarts[11] = storageOffset;
244     pieceTable.insert(0, BaseSize, &storageOffset);   // 12
245     changeStarts[12] = storageOffset;
246 
247     // test
248     QCOMPARE(pieceTable.size(), BaseSize + 12 * BaseSize);
249     QCOMPARE(pieceTable.changesCount(), 9);   // 9+10, 5+6, 1+2 are merged
250     QCOMPARE(pieceTable.appliedChangesCount(), 9);
251     QCOMPARE(storageOffset, 11 * BaseSize);
252 
253     // all borders
254     // 12: begin
255     int byteArrayOffset = 0;
256     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
257     QVERIFY(result);
258     QCOMPARE(storageOffset, changeStarts[12]);
259     QCOMPARE(storageId, (int)Piece::ChangeStorage);
260 
261     // 12: end
262     byteArrayOffset += BaseSize;
263     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
264     QVERIFY(result);
265     QCOMPARE(storageOffset, changeStarts[12] + BaseSize - 1);
266     QCOMPARE(storageId, (int)Piece::ChangeStorage);
267     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
268     QVERIFY(result);
269     QCOMPARE(storageOffset, changeStarts[9]);
270     QCOMPARE(storageId, (int)Piece::ChangeStorage);
271 
272     // 11: begin
273     byteArrayOffset += HalfBaseSize;
274     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
275     QVERIFY(result);
276     QCOMPARE(storageOffset, changeStarts[9] + HalfBaseSize - 1);
277     QCOMPARE(storageId, (int)Piece::ChangeStorage);
278     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
279     QVERIFY(result);
280     QCOMPARE(storageOffset, changeStarts[11]);
281     QCOMPARE(storageId, (int)Piece::ChangeStorage);
282 
283     // 11: end
284     byteArrayOffset += BaseSize;
285     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
286     QVERIFY(result);
287     QCOMPARE(storageOffset, changeStarts[11] + BaseSize - 1);
288     QCOMPARE(storageId, (int)Piece::ChangeStorage);
289     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
290     QVERIFY(result);
291     QCOMPARE(storageOffset, changeStarts[9] + HalfBaseSize);
292     QCOMPARE(storageId, (int)Piece::ChangeStorage);
293 
294     // 10: begin
295     byteArrayOffset += HalfBaseSize;
296     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
297     QVERIFY(result);
298     QCOMPARE(storageOffset, changeStarts[9] + BaseSize - 1);
299     QCOMPARE(storageId, (int)Piece::ChangeStorage);
300     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
301     QVERIFY(result);
302     QCOMPARE(storageOffset, changeStarts[10]);
303     QCOMPARE(storageId, (int)Piece::ChangeStorage);
304 
305     // 10: end
306     byteArrayOffset += BaseSize;
307     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
308     QVERIFY(result);
309     QCOMPARE(storageOffset, changeStarts[10] + BaseSize - 1);
310     QCOMPARE(storageId, (int)Piece::ChangeStorage);
311     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
312     QVERIFY(result);
313     QCOMPARE(storageOffset, 0);
314     QCOMPARE(storageId, (int)Piece::OriginalStorage);
315 
316     // 8: begin
317     byteArrayOffset += HalfBaseSize;
318     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
319     QVERIFY(result);
320     QCOMPARE(storageOffset, HalfBaseSize - 1);
321     QCOMPARE(storageId, (int)Piece::OriginalStorage);
322     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
323     QVERIFY(result);
324     QCOMPARE(storageOffset, changeStarts[8]);
325     QCOMPARE(storageId, (int)Piece::ChangeStorage);
326 
327     // 8: end
328     byteArrayOffset += BaseSize;
329     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
330     QVERIFY(result);
331     QCOMPARE(storageOffset, changeStarts[8] + BaseSize - 1);
332     QCOMPARE(storageId, (int)Piece::ChangeStorage);
333     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
334     QVERIFY(result);
335     QCOMPARE(storageOffset, changeStarts[5]);
336     QCOMPARE(storageId, (int)Piece::ChangeStorage);
337 
338     // 7: begin
339     byteArrayOffset += HalfBaseSize;
340     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
341     QVERIFY(result);
342     QCOMPARE(storageOffset, changeStarts[5] + HalfBaseSize - 1);
343     QCOMPARE(storageId, (int)Piece::ChangeStorage);
344     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
345     QVERIFY(result);
346     QCOMPARE(storageOffset, changeStarts[7]);
347     QCOMPARE(storageId, (int)Piece::ChangeStorage);
348 
349     // 7: end
350     byteArrayOffset += BaseSize;
351     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
352     QVERIFY(result);
353     QCOMPARE(storageOffset, changeStarts[7] + BaseSize - 1);
354     QCOMPARE(storageId, (int)Piece::ChangeStorage);
355     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
356     QVERIFY(result);
357     QCOMPARE(storageOffset, changeStarts[5] + HalfBaseSize);
358     QCOMPARE(storageId, (int)Piece::ChangeStorage);
359 
360     // 6: begin
361     byteArrayOffset += HalfBaseSize;
362     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
363     QVERIFY(result);
364     QCOMPARE(storageOffset, changeStarts[5] + BaseSize - 1);
365     QCOMPARE(storageId, (int)Piece::ChangeStorage);
366     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
367     QVERIFY(result);
368     QCOMPARE(storageOffset, changeStarts[6]);
369     QCOMPARE(storageId, (int)Piece::ChangeStorage);
370 
371     // 6: end
372     byteArrayOffset += BaseSize;
373     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
374     QVERIFY(result);
375     QCOMPARE(storageOffset, changeStarts[6] + BaseSize - 1);
376     QCOMPARE(storageId, (int)Piece::ChangeStorage);
377     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
378     QVERIFY(result);
379     QCOMPARE(storageOffset, HalfBaseSize);
380     QCOMPARE(storageId, (int)Piece::OriginalStorage);
381 
382     // 4: begin
383     byteArrayOffset += HalfBaseSize;
384     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
385     QVERIFY(result);
386     QCOMPARE(storageOffset, BaseSize - 1);
387     QCOMPARE(storageId, (int)Piece::OriginalStorage);
388     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
389     QVERIFY(result);
390     QCOMPARE(storageOffset, changeStarts[4]);
391     QCOMPARE(storageId, (int)Piece::ChangeStorage);
392 
393     // 4: end
394     byteArrayOffset += BaseSize;
395     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
396     QVERIFY(result);
397     QCOMPARE(storageOffset, changeStarts[4] + BaseSize - 1);
398     QCOMPARE(storageId, (int)Piece::ChangeStorage);
399     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
400     QVERIFY(result);
401     QCOMPARE(storageOffset, changeStarts[1]);
402     QCOMPARE(storageId, (int)Piece::ChangeStorage);
403 
404     // 3: begin
405     byteArrayOffset += HalfBaseSize;
406     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
407     QVERIFY(result);
408     QCOMPARE(storageOffset, changeStarts[1] + HalfBaseSize - 1);
409     QCOMPARE(storageId, (int)Piece::ChangeStorage);
410     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
411     QVERIFY(result);
412     QCOMPARE(storageOffset, changeStarts[3]);
413     QCOMPARE(storageId, (int)Piece::ChangeStorage);
414 
415     // 3: end
416     byteArrayOffset += BaseSize;
417     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
418     QVERIFY(result);
419     QCOMPARE(storageOffset, changeStarts[3] + BaseSize - 1);
420     QCOMPARE(storageId, (int)Piece::ChangeStorage);
421     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
422     QVERIFY(result);
423     QCOMPARE(storageOffset, changeStarts[1] + HalfBaseSize);
424     QCOMPARE(storageId, (int)Piece::ChangeStorage);
425 
426     // 2: begin
427     byteArrayOffset += HalfBaseSize;
428     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
429     QVERIFY(result);
430     QCOMPARE(storageOffset, changeStarts[1] + BaseSize - 1);
431     QCOMPARE(storageId, (int)Piece::ChangeStorage);
432     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
433     QVERIFY(result);
434     QCOMPARE(storageOffset, changeStarts[2]);
435     QCOMPARE(storageId, (int)Piece::ChangeStorage);
436 
437     // 2: end
438     byteArrayOffset += BaseSize;
439     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
440     QVERIFY(result);
441     QCOMPARE(storageOffset, changeStarts[2] + BaseSize - 1);
442     QCOMPARE(storageId, (int)Piece::ChangeStorage);
443 
444     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
445     QVERIFY(!result);
446 }
447 
testRemove()448 void RevertablePieceTableTest::testRemove()
449 {
450     RevertablePieceTable pieceTable;
451 
452     int changeStarts[6];
453     int storageId;
454     int storageOffset;
455     bool result;
456 
457     // removing at begin
458     pieceTable.init(BaseSize);
459     pieceTable.remove(AddressRange(0, Start - 1));
460 
461     QCOMPARE(pieceTable.size(), BaseSize - Start);
462     QCOMPARE(pieceTable.changesCount(), 1);
463     QCOMPARE(pieceTable.appliedChangesCount(), 1);
464 
465     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
466     QVERIFY(result);
467     QCOMPARE(storageOffset, Start);
468     QCOMPARE(storageId, (int)Piece::OriginalStorage);
469 
470     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Start - 1);
471     QVERIFY(result);
472     QCOMPARE(storageOffset, BaseSize - 1);
473     QCOMPARE(storageId, (int)Piece::OriginalStorage);
474 
475     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Start);
476     QVERIFY(!result);
477 
478     // removing at middle
479     pieceTable.init(BaseSize);
480     pieceTable.remove(AddressRange(Start, End));
481 
482     QCOMPARE(pieceTable.size(), BaseSize - Width);
483     QCOMPARE(pieceTable.changesCount(), 1);
484     QCOMPARE(pieceTable.appliedChangesCount(), 1);
485 
486     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
487     QVERIFY(result);
488     QCOMPARE(storageOffset, Start - 1);
489     QCOMPARE(storageId, (int)Piece::OriginalStorage);
490 
491     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
492     QVERIFY(result);
493     QCOMPARE(storageOffset, End + 1);
494     QCOMPARE(storageId, (int)Piece::OriginalStorage);
495 
496     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Width - 1);
497     QVERIFY(result);
498     QCOMPARE(storageOffset, BaseSize - 1);
499     QCOMPARE(storageId, (int)Piece::OriginalStorage);
500 
501     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Width);
502     QVERIFY(!result);
503 
504     // removing at end
505     pieceTable.init(BaseSize);
506     pieceTable.remove(AddressRange(End + 1, BaseSize - 1));
507 
508     QCOMPARE(pieceTable.size(), End + 1);
509     QCOMPARE(pieceTable.changesCount(), 1);
510     QCOMPARE(pieceTable.appliedChangesCount(), 1);
511 
512     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
513     QVERIFY(result);
514     QCOMPARE(storageOffset, End);
515     QCOMPARE(storageId, (int)Piece::OriginalStorage);
516 
517     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
518     QVERIFY(!result);
519 
520     // removing all
521     pieceTable.init(BaseSize);
522     pieceTable.remove(AddressRange::fromWidth(BaseSize));
523 
524     QCOMPARE(pieceTable.size(), 0);
525     QCOMPARE(pieceTable.changesCount(), 1);
526     QCOMPARE(pieceTable.appliedChangesCount(), 1);
527 
528     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
529     QVERIFY(!result);
530 
531     // removing a lot:
532     const int pieceCount = 5;
533     const int mid = (pieceCount + 1) / 2;
534     const int midPieceOffset = BaseSize * (mid - 1);
535     const int fullSize = pieceCount * BaseSize;
536     // for this five equally sized pieces are inserted, reverse to offset in ChangeStore
537     for (int i = 0; i < pieceCount; ++i) {
538         changeStarts[pieceCount - i] = BaseSize * i;
539     }
540 
541     // removing inside a piece in the middle
542     fillWithSize(&pieceTable, pieceCount);
543     pieceTable.remove(AddressRange::fromWidth(midPieceOffset + Start, Width));
544 
545     QCOMPARE(pieceTable.size(), fullSize - Width);
546     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
547     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
548 
549     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + Start - 1);
550     QVERIFY(result);
551     QCOMPARE(storageOffset, changeStarts[mid] + Start - 1);
552     QCOMPARE(storageId, (int)Piece::ChangeStorage);
553 
554     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + Start);
555     QVERIFY(result);
556     QCOMPARE(storageOffset, changeStarts[mid] + End + 1);
557     QCOMPARE(storageId, (int)Piece::ChangeStorage);
558 
559     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Width - 1);
560     QVERIFY(result);
561     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
562     QCOMPARE(storageId, (int)Piece::ChangeStorage);
563 
564     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Width);
565     QVERIFY(!result);
566 
567     // removing start of a piece in the middle
568     fillWithSize(&pieceTable, pieceCount);
569     pieceTable.remove(AddressRange::fromWidth(midPieceOffset, Start));
570 
571     QCOMPARE(pieceTable.size(), fullSize - Start);
572     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
573     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
574 
575     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - 1);
576     QVERIFY(result);
577     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - 1);
578     QCOMPARE(storageId, (int)Piece::ChangeStorage);
579 
580     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset);
581     QVERIFY(result);
582     QCOMPARE(storageOffset, changeStarts[mid] + Start);
583     QCOMPARE(storageId, (int)Piece::ChangeStorage);
584 
585     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start - 1);
586     QVERIFY(result);
587     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
588     QCOMPARE(storageId, (int)Piece::ChangeStorage);
589 
590     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start);
591     QVERIFY(!result);
592 
593     // removing end of a piece in the middle
594     fillWithSize(&pieceTable, pieceCount);
595     pieceTable.remove(AddressRange::fromWidth(midPieceOffset + End + 1, BaseSize - (End + 1)));
596 
597     QCOMPARE(pieceTable.size(), fullSize - (BaseSize - End - 1));
598     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
599     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
600 
601     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + End);
602     QVERIFY(result);
603     QCOMPARE(storageOffset, changeStarts[mid] + End);
604     QCOMPARE(storageId, (int)Piece::ChangeStorage);
605 
606     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + End + 1);
607     QVERIFY(result);
608     QCOMPARE(storageOffset, changeStarts[mid + 1]);
609     QCOMPARE(storageId, (int)Piece::ChangeStorage);
610 
611     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - (BaseSize - End - 1) - 1);
612     QVERIFY(result);
613     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
614     QCOMPARE(storageId, (int)Piece::ChangeStorage);
615 
616     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - (BaseSize - End - 1));
617     QVERIFY(!result);
618 
619     // removing whole piece in the middle
620     fillWithSize(&pieceTable, pieceCount);
621     pieceTable.remove(AddressRange::fromWidth(midPieceOffset, BaseSize));
622 
623     QCOMPARE(pieceTable.size(), fullSize - BaseSize);
624     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
625     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
626 
627     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - 1);
628     QVERIFY(result);
629     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - 1);
630     QCOMPARE(storageId, (int)Piece::ChangeStorage);
631 
632     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset);
633     QVERIFY(result);
634     QCOMPARE(storageOffset, changeStarts[mid + 1]);
635     QCOMPARE(storageId, (int)Piece::ChangeStorage);
636 
637     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - 1);
638     QVERIFY(result);
639     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
640     QCOMPARE(storageId, (int)Piece::ChangeStorage);
641 
642     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize);
643     QVERIFY(!result);
644 
645     // removing whole piece and start of next in the middke
646     fillWithSize(&pieceTable, pieceCount);
647     pieceTable.remove(AddressRange::fromWidth(midPieceOffset, BaseSize + Start));
648 
649     QCOMPARE(pieceTable.size(), fullSize - BaseSize - Start);
650     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
651     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
652 
653     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - 1);
654     QVERIFY(result);
655     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - 1);
656     QCOMPARE(storageId, (int)Piece::ChangeStorage);
657 
658     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset);
659     QVERIFY(result);
660     QCOMPARE(storageOffset, changeStarts[mid + 1] + Start);
661     QCOMPARE(storageId, (int)Piece::ChangeStorage);
662 
663     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start - 1);
664     QVERIFY(result);
665     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
666     QCOMPARE(storageId, (int)Piece::ChangeStorage);
667 
668     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start);
669     QVERIFY(!result);
670 
671     // removing whole piece and end of previous in the middle
672     fillWithSize(&pieceTable, pieceCount);
673     pieceTable.remove(AddressRange::fromWidth(midPieceOffset - (BaseSize - End - 1), BaseSize + BaseSize - (End + 1)));
674 
675     QCOMPARE(pieceTable.size(), fullSize - BaseSize - (BaseSize - End - 1));
676     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
677     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
678 
679     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1) - 1);
680     QVERIFY(result);
681     QCOMPARE(storageOffset, changeStarts[mid - 1] + End);
682     QCOMPARE(storageId, (int)Piece::ChangeStorage);
683 
684     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1));
685     QVERIFY(result);
686     QCOMPARE(storageOffset, changeStarts[mid + 1]);
687     QCOMPARE(storageId, (int)Piece::ChangeStorage);
688 
689     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - 1);
690     QVERIFY(result);
691     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
692     QCOMPARE(storageId, (int)Piece::ChangeStorage);
693 
694     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1));
695     QVERIFY(!result);
696 
697     // removing end of previous, whole and start of next in the middle
698     fillWithSize(&pieceTable, pieceCount);
699     pieceTable.remove(AddressRange::fromWidth(midPieceOffset - (BaseSize - End - 1), Start + BaseSize + BaseSize - (End + 1)));
700 
701     QCOMPARE(pieceTable.size(), fullSize - BaseSize - (BaseSize - End - 1) - Start);
702     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
703     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
704 
705     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1) - 1);
706     QVERIFY(result);
707     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - (BaseSize - End - 1) - 1);
708     QCOMPARE(storageId, (int)Piece::ChangeStorage);
709 
710     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1));
711     QVERIFY(result);
712     QCOMPARE(storageOffset, changeStarts[mid + 1] + Start);
713     QCOMPARE(storageId, (int)Piece::ChangeStorage);
714 
715     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - Start - 1);
716     QVERIFY(result);
717     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
718     QCOMPARE(storageId, (int)Piece::ChangeStorage);
719 
720     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - Start);
721     QVERIFY(!result);
722 
723     // removing start of piece at start
724     fillWithSize(&pieceTable, pieceCount);
725     pieceTable.remove(AddressRange::fromWidth(Start));
726 
727     QCOMPARE(pieceTable.size(), fullSize - Start);
728     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
729     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
730 
731     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
732     QVERIFY(result);
733     QCOMPARE(storageOffset, changeStarts[1] + Start);
734     QCOMPARE(storageId, (int)Piece::ChangeStorage);
735 
736     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start - 1);
737     QVERIFY(result);
738     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
739     QCOMPARE(storageId, (int)Piece::ChangeStorage);
740 
741     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start);
742     QVERIFY(!result);
743 
744     // removing whole piece at start
745     fillWithSize(&pieceTable, pieceCount);
746     pieceTable.remove(AddressRange::fromWidth(BaseSize));
747 
748     QCOMPARE(pieceTable.size(), fullSize - BaseSize);
749     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
750     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
751 
752     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
753     QVERIFY(result);
754     QCOMPARE(storageOffset, changeStarts[2]);
755     QCOMPARE(storageId, (int)Piece::ChangeStorage);
756 
757     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - 1);
758     QVERIFY(result);
759     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
760     QCOMPARE(storageId, (int)Piece::ChangeStorage);
761 
762     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize);
763     QVERIFY(!result);
764 
765     // removing whole piece and start of next at start
766     fillWithSize(&pieceTable, pieceCount);
767     pieceTable.remove(AddressRange::fromWidth(BaseSize + Start));
768 
769     QCOMPARE(pieceTable.size(), fullSize - BaseSize - Start);
770     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
771     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
772 
773     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
774     QVERIFY(result);
775     QCOMPARE(storageOffset, changeStarts[2] + Start);
776     QCOMPARE(storageId, (int)Piece::ChangeStorage);
777 
778     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start - 1);
779     QVERIFY(result);
780     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
781     QCOMPARE(storageId, (int)Piece::ChangeStorage);
782 
783     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start);
784     QVERIFY(!result);
785 
786     // removing end of piece at end
787     fillWithSize(&pieceTable, pieceCount);
788     pieceTable.remove(AddressRange::fromWidth(fullSize - BaseSize + End + 1, BaseSize - (End + 1)));
789 
790     QCOMPARE(pieceTable.size(), fullSize - (BaseSize - End - 1));
791     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
792     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
793 
794     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize + End);
795     QVERIFY(result);
796     QCOMPARE(storageOffset, changeStarts[pieceCount] + End);
797     QCOMPARE(storageId, (int)Piece::ChangeStorage);
798 
799     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - (BaseSize - End - 1));
800     QVERIFY(!result);
801 
802     // removing whole piece at end
803     fillWithSize(&pieceTable, pieceCount);
804     pieceTable.remove(AddressRange::fromWidth(fullSize - BaseSize, BaseSize));
805 
806     QCOMPARE(pieceTable.size(), fullSize - BaseSize);
807     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
808     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
809 
810     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - 1);
811     QVERIFY(result);
812     QCOMPARE(storageOffset, changeStarts[pieceCount - 1] + BaseSize - 1);
813     QCOMPARE(storageId, (int)Piece::ChangeStorage);
814 
815     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize);
816     QVERIFY(!result);
817 
818     // removing whole piece and end of previous at end
819     fillWithSize(&pieceTable, pieceCount);
820     pieceTable.remove(AddressRange::fromWidth(fullSize - BaseSize - (BaseSize - End - 1), BaseSize + BaseSize - (End + 1)));
821 
822     QCOMPARE(pieceTable.size(), fullSize - BaseSize - (BaseSize - End - 1));
823     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
824     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
825 
826     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - 1);
827     QVERIFY(result);
828     QCOMPARE(storageOffset, changeStarts[pieceCount - 1] + End);
829     QCOMPARE(storageId, (int)Piece::ChangeStorage);
830 
831     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1));
832     QVERIFY(!result);
833 
834     // removing all
835     fillWithSize(&pieceTable, pieceCount);
836     pieceTable.remove(AddressRange::fromWidth(fullSize));
837 
838     QCOMPARE(pieceTable.size(), 0);
839     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
840     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
841 
842     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
843     QVERIFY(!result);
844 }
845 
testSwap()846 void RevertablePieceTableTest::testSwap()
847 {
848     RevertablePieceTable pieceTable;
849 
850     int storageId;
851     int storageOffset;
852     bool result;
853 
854     // moving end at begin
855     pieceTable.init(BaseSize);
856     pieceTable.swap(0, AddressRange::fromWidth(End + 1, BaseSize - (End + 1)));
857 
858     QCOMPARE(pieceTable.size(), BaseSize);
859     QCOMPARE(pieceTable.changesCount(), 1);
860     QCOMPARE(pieceTable.appliedChangesCount(), 1);
861 
862     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
863     QVERIFY(result);
864     QCOMPARE(storageOffset, End + 1);
865     QCOMPARE(storageId, (int)Piece::OriginalStorage);
866 
867     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - End - 2);
868     QVERIFY(result);
869     QCOMPARE(storageOffset, BaseSize - 1);
870     QCOMPARE(storageId, (int)Piece::OriginalStorage);
871 
872     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - End - 1);
873     QVERIFY(result);
874     QCOMPARE(storageOffset, 0);
875     QCOMPARE(storageId, (int)Piece::OriginalStorage);
876 
877     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
878     QVERIFY(result);
879     QCOMPARE(storageOffset, End);
880     QCOMPARE(storageId, (int)Piece::OriginalStorage);
881 
882     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
883     QVERIFY(!result);
884 
885     // moving end at mid
886     pieceTable.init(BaseSize);
887     pieceTable.swap(Start, AddressRange::fromWidth(End + 1, BaseSize - (End + 1)));
888 
889     QCOMPARE(pieceTable.size(), BaseSize);
890     QCOMPARE(pieceTable.changesCount(), 1);
891     QCOMPARE(pieceTable.appliedChangesCount(), 1);
892 
893     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
894     QVERIFY(result);
895     QCOMPARE(storageOffset, Start - 1);
896     QCOMPARE(storageId, (int)Piece::OriginalStorage);
897 
898     QCOMPARE(pieceTable.size(), BaseSize);
899     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
900     QVERIFY(result);
901     QCOMPARE(storageOffset, End + 1);
902     QCOMPARE(storageId, (int)Piece::OriginalStorage);
903 
904     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + BaseSize - End - 2);
905     QVERIFY(result);
906     QCOMPARE(storageOffset, BaseSize - 1);
907     QCOMPARE(storageId, (int)Piece::OriginalStorage);
908 
909     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + BaseSize - End - 1);
910     QVERIFY(result);
911     QCOMPARE(storageOffset, Start);
912     QCOMPARE(storageId, (int)Piece::OriginalStorage);
913 
914     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
915     QVERIFY(result);
916     QCOMPARE(storageOffset, End);
917     QCOMPARE(storageId, (int)Piece::OriginalStorage);
918 
919     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
920     QVERIFY(!result);
921 
922     // moving mid at begin
923     pieceTable.init(BaseSize);
924     pieceTable.swap(0, AddressRange::fromWidth(Start, Width));
925 
926     QCOMPARE(pieceTable.size(), BaseSize);
927     QCOMPARE(pieceTable.changesCount(), 1);
928     QCOMPARE(pieceTable.appliedChangesCount(), 1);
929 
930     QCOMPARE(pieceTable.size(), BaseSize);
931     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
932     QVERIFY(result);
933     QCOMPARE(storageOffset, Start);
934     QCOMPARE(storageId, (int)Piece::OriginalStorage);
935 
936     result = pieceTable.getStorageData(&storageId, &storageOffset, Width - 1);
937     QVERIFY(result);
938     QCOMPARE(storageOffset, End);
939     QCOMPARE(storageId, (int)Piece::OriginalStorage);
940 
941     result = pieceTable.getStorageData(&storageId, &storageOffset, Width);
942     QVERIFY(result);
943     QCOMPARE(storageOffset, 0);
944     QCOMPARE(storageId, (int)Piece::OriginalStorage);
945 
946     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
947     QVERIFY(result);
948     QCOMPARE(storageOffset, Start - 1);
949     QCOMPARE(storageId, (int)Piece::OriginalStorage);
950 
951     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
952     QVERIFY(result);
953     QCOMPARE(storageOffset, End + 1);
954     QCOMPARE(storageId, (int)Piece::OriginalStorage);
955 
956     // moving mid at mid
957     pieceTable.init(BaseSize);
958     int mid = (End + Start) / 2;
959     pieceTable.swap(Start, AddressRange::fromWidth(mid, End - mid + 1));
960 
961     QCOMPARE(pieceTable.size(), BaseSize);
962     QCOMPARE(pieceTable.changesCount(), 1);
963     QCOMPARE(pieceTable.appliedChangesCount(), 1);
964 
965     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
966     QVERIFY(result);
967     QCOMPARE(storageOffset, Start - 1);
968     QCOMPARE(storageId, (int)Piece::OriginalStorage);
969 
970     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
971     QVERIFY(result);
972     QCOMPARE(storageOffset, mid);
973     QCOMPARE(storageId, (int)Piece::OriginalStorage);
974 
975     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + End - mid);
976     QVERIFY(result);
977     QCOMPARE(storageOffset, End);
978     QCOMPARE(storageId, (int)Piece::OriginalStorage);
979 
980     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + End - mid + 1);
981     QVERIFY(result);
982     QCOMPARE(storageOffset, Start);
983     QCOMPARE(storageId, (int)Piece::OriginalStorage);
984 
985     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
986     QVERIFY(result);
987     QCOMPARE(storageOffset, mid - 1);
988     QCOMPARE(storageId, (int)Piece::OriginalStorage);
989 
990     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
991     QVERIFY(result);
992     QCOMPARE(storageOffset, End + 1);
993     QCOMPARE(storageId, (int)Piece::OriginalStorage);
994 
995     // moving a lot:
996     const int pieceCount = 5;
997     const int fullSize = pieceCount * BaseSize;
998 
999     // moving start of piece at start
1000     fillWithSize(&pieceTable, pieceCount);
1001     pieceTable.swap(Start, AddressRange::fromWidth(mid, End - mid + 1));
1002 
1003     QCOMPARE(pieceTable.size(), fullSize);
1004     // TODO: add other tests
1005 }
1006 
1007 }
1008 
1009 QTEST_GUILESS_MAIN(KPieceTable::RevertablePieceTableTest)
1010