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