piecetable/tests/revertablepiecetabletest.cpp

0001 /*
0002     This file is part of the Okteta Core library, made within the KDE community.
0003
0004     SPDX-FileCopyrightText: 2008 Friedrich W. H. Kossebau <kossebau@kde.org>
0005
0006     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0007 */
0008
0009 #include "revertablepiecetabletest.hpp"
0010
0011 // test object
0012 #include <piecetable/revertablepiecetable.hpp>
0013 // Qt
0014 #include <QTest>
0015
0016 namespace KPieceTable {
0017
0018 // local variables
0019 static constexpr Address Start = 15;
0020 static constexpr Address End = 27;
0021 static constexpr Size HalfBaseSize = 50;
0022 static constexpr Size BaseSize = 2 * HalfBaseSize;
0023
0024 static constexpr Size Width = End - Start + 1;
0025
0026 static constexpr Address ChangeStart = 0;
0027 static constexpr Address ChangeEnd = ChangeStart + Width - 1;
0028
0029 void RevertablePieceTableTest::testSimpleConstructor()
0030 {
0031     RevertablePieceTable pieceTable;
0032     QCOMPARE(pieceTable.size(), 0);
0033     QCOMPARE(pieceTable.changesCount(), 0);
0034     QCOMPARE(pieceTable.appliedChangesCount(), 0);
0035 }
0036
0037 void RevertablePieceTableTest::testInit()
0038 {
0039     RevertablePieceTable pieceTable;
0040
0041     pieceTable.init(BaseSize);
0042     int storageId;
0043     int storageOffset;
0044
0045     QCOMPARE(pieceTable.size(), BaseSize);
0046     QCOMPARE(pieceTable.changesCount(), 0);
0047     QCOMPARE(pieceTable.appliedChangesCount(), 0);
0048
0049     bool result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0050     QVERIFY(result);
0051     QCOMPARE(storageOffset, 0);
0052     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0053
0054     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
0055     QVERIFY(result);
0056     QCOMPARE(storageOffset, Start);
0057     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0058
0059     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
0060     QVERIFY(result);
0061     QCOMPARE(storageOffset, End);
0062     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0063
0064     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
0065     QVERIFY(result);
0066     QCOMPARE(storageOffset, BaseSize - 1);
0067     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0068
0069     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
0070     QVERIFY(!result);
0071 }
0072
0073 static void fillWithSize(RevertablePieceTable* pieceTable, int count)
0074 {
0075     int dummy;
0076     pieceTable->init(0);
0077     for (int i = 0; i < count; ++i) {
0078         pieceTable->insert(0, BaseSize, &dummy);
0079     }
0080 }
0081
0082 void RevertablePieceTableTest::testInsert()
0083 {
0084     RevertablePieceTable pieceTable;
0085
0086     int storageId;
0087     int storageOffset;
0088     bool result;
0089
0090     // inserting to empty
0091     pieceTable.init(0);
0092     pieceTable.insert(0, Width, &storageOffset);
0093
0094     QCOMPARE(pieceTable.size(), Width);
0095     QCOMPARE(pieceTable.changesCount(), 1);
0096     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0097     QCOMPARE(storageOffset, ChangeStart);
0098
0099     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0100     QVERIFY(result);
0101     QCOMPARE(storageOffset, ChangeStart);
0102     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0103
0104     result = pieceTable.getStorageData(&storageId, &storageOffset, Width - 1);
0105     QVERIFY(result);
0106     QCOMPARE(storageOffset, ChangeEnd);
0107     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0108
0109     result = pieceTable.getStorageData(&storageId, &storageOffset, Width);
0110     QVERIFY(!result);
0111
0112     // inserting one at the begin
0113     pieceTable.init(BaseSize);
0114     pieceTable.insert(0, Width, &storageOffset);
0115
0116     QCOMPARE(pieceTable.size(), BaseSize + Width);
0117     QCOMPARE(pieceTable.changesCount(), 1);
0118     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0119     QCOMPARE(storageOffset, ChangeStart);
0120
0121     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0122     QVERIFY(result);
0123     QCOMPARE(storageOffset, ChangeStart);
0124     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0125
0126     result = pieceTable.getStorageData(&storageId, &storageOffset, Width - 1);
0127     QVERIFY(result);
0128     QCOMPARE(storageOffset, ChangeEnd);
0129     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0130
0131     result = pieceTable.getStorageData(&storageId, &storageOffset, Width);
0132     QVERIFY(result);
0133     QCOMPARE(storageOffset, 0);
0134     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0135
0136     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width - 1);
0137     QVERIFY(result);
0138     QCOMPARE(storageOffset, BaseSize - 1);
0139     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0140
0141     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width);
0142     QVERIFY(!result);
0143
0144     // inserting one in the middle
0145     pieceTable.init(BaseSize);
0146     pieceTable.insert(Start, Width, &storageOffset);
0147
0148     QCOMPARE(pieceTable.size(), BaseSize + Width);
0149     QCOMPARE(pieceTable.changesCount(), 1);
0150     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0151     QCOMPARE(storageOffset, ChangeStart);
0152
0153     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
0154     QVERIFY(result);
0155     QCOMPARE(storageOffset, Start - 1);
0156     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0157
0158     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
0159     QVERIFY(result);
0160     QCOMPARE(storageOffset, ChangeStart);
0161     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0162
0163     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
0164     QVERIFY(result);
0165     QCOMPARE(storageOffset, ChangeEnd);
0166     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0167
0168     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
0169     QVERIFY(result);
0170     QCOMPARE(storageOffset, Start);
0171     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0172
0173     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width - 1);
0174     QVERIFY(result);
0175     QCOMPARE(storageOffset, BaseSize - 1);
0176     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0177
0178     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width);
0179     QVERIFY(!result);
0180
0181     // inserting one at the end
0182     pieceTable.init(BaseSize);
0183     pieceTable.insert(BaseSize, Width, &storageOffset);
0184
0185     QCOMPARE(pieceTable.size(), BaseSize + Width);
0186     QCOMPARE(pieceTable.changesCount(), 1);
0187     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0188     QCOMPARE(storageOffset, ChangeStart);
0189
0190     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
0191     QVERIFY(result);
0192     QCOMPARE(storageOffset, BaseSize - 1);
0193     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0194
0195     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
0196     QVERIFY(result);
0197     QCOMPARE(storageOffset, ChangeStart);
0198     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0199
0200     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width - 1);
0201     QVERIFY(result);
0202     QCOMPARE(storageOffset, ChangeEnd);
0203     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0204
0205     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize + Width);
0206     QVERIFY(!result);
0207
0208     // inserting a lot:
0209     // inserting before, after and in another inserted section, two recursions
0210     // 121110  8 7 6  4 3 2
0211     // \/\/\/ \/\/\/ \/\/\/
0212     //  |-9-|  |-5-|  |-1-|
0213     //  \  /   \  /   \  /
0214     //   \/     \/     \/
0215     //    |-----0-------|
0216     // TODO: do this also in forward sequences
0217     pieceTable.init(BaseSize);   // 0
0218     const int Mid = BaseSize / 2;
0219     int changeStarts[13];
0220     pieceTable.insert(BaseSize, BaseSize, &storageOffset);   // 1
0221     changeStarts[1] = storageOffset;
0222     pieceTable.insert(BaseSize + BaseSize, BaseSize, &storageOffset); // 2
0223     changeStarts[2] = storageOffset;
0224     pieceTable.insert(BaseSize + Mid, BaseSize, &storageOffset); // 3
0225     changeStarts[3] = storageOffset;
0226     pieceTable.insert(BaseSize, BaseSize, &storageOffset);   // 4
0227     changeStarts[4] = storageOffset;
0228
0229     pieceTable.insert(Mid, BaseSize, &storageOffset);   // 5
0230     changeStarts[5] = storageOffset;
0231     pieceTable.insert(Mid + BaseSize, BaseSize, &storageOffset); // 6
0232     changeStarts[6] = storageOffset;
0233     pieceTable.insert(Mid + Mid, BaseSize, &storageOffset); // 7
0234     changeStarts[7] = storageOffset;
0235     pieceTable.insert(Mid, BaseSize, &storageOffset);   // 8
0236     changeStarts[8] = storageOffset;
0237
0238     pieceTable.insert(0, BaseSize, &storageOffset);   // 9
0239     changeStarts[9] = storageOffset;
0240     pieceTable.insert(BaseSize, BaseSize, &storageOffset);   // 10
0241     changeStarts[10] = storageOffset;
0242     pieceTable.insert(Mid, BaseSize, &storageOffset);   // 11
0243     changeStarts[11] = storageOffset;
0244     pieceTable.insert(0, BaseSize, &storageOffset);   // 12
0245     changeStarts[12] = storageOffset;
0246
0247     // test
0248     QCOMPARE(pieceTable.size(), BaseSize + 12 * BaseSize);
0249     QCOMPARE(pieceTable.changesCount(), 9);   // 9+10, 5+6, 1+2 are merged
0250     QCOMPARE(pieceTable.appliedChangesCount(), 9);
0251     QCOMPARE(storageOffset, 11 * BaseSize);
0252
0253     // all borders
0254     // 12: begin
0255     int byteArrayOffset = 0;
0256     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0257     QVERIFY(result);
0258     QCOMPARE(storageOffset, changeStarts[12]);
0259     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0260
0261     // 12: end
0262     byteArrayOffset += BaseSize;
0263     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0264     QVERIFY(result);
0265     QCOMPARE(storageOffset, changeStarts[12] + BaseSize - 1);
0266     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0267     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0268     QVERIFY(result);
0269     QCOMPARE(storageOffset, changeStarts[9]);
0270     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0271
0272     // 11: begin
0273     byteArrayOffset += HalfBaseSize;
0274     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0275     QVERIFY(result);
0276     QCOMPARE(storageOffset, changeStarts[9] + HalfBaseSize - 1);
0277     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0278     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0279     QVERIFY(result);
0280     QCOMPARE(storageOffset, changeStarts[11]);
0281     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0282
0283     // 11: end
0284     byteArrayOffset += BaseSize;
0285     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0286     QVERIFY(result);
0287     QCOMPARE(storageOffset, changeStarts[11] + BaseSize - 1);
0288     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0289     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0290     QVERIFY(result);
0291     QCOMPARE(storageOffset, changeStarts[9] + HalfBaseSize);
0292     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0293
0294     // 10: begin
0295     byteArrayOffset += HalfBaseSize;
0296     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0297     QVERIFY(result);
0298     QCOMPARE(storageOffset, changeStarts[9] + BaseSize - 1);
0299     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0300     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0301     QVERIFY(result);
0302     QCOMPARE(storageOffset, changeStarts[10]);
0303     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0304
0305     // 10: end
0306     byteArrayOffset += BaseSize;
0307     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0308     QVERIFY(result);
0309     QCOMPARE(storageOffset, changeStarts[10] + BaseSize - 1);
0310     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0311     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0312     QVERIFY(result);
0313     QCOMPARE(storageOffset, 0);
0314     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0315
0316     // 8: begin
0317     byteArrayOffset += HalfBaseSize;
0318     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0319     QVERIFY(result);
0320     QCOMPARE(storageOffset, HalfBaseSize - 1);
0321     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0322     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0323     QVERIFY(result);
0324     QCOMPARE(storageOffset, changeStarts[8]);
0325     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0326
0327     // 8: end
0328     byteArrayOffset += BaseSize;
0329     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0330     QVERIFY(result);
0331     QCOMPARE(storageOffset, changeStarts[8] + BaseSize - 1);
0332     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0333     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0334     QVERIFY(result);
0335     QCOMPARE(storageOffset, changeStarts[5]);
0336     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0337
0338     // 7: begin
0339     byteArrayOffset += HalfBaseSize;
0340     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0341     QVERIFY(result);
0342     QCOMPARE(storageOffset, changeStarts[5] + HalfBaseSize - 1);
0343     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0344     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0345     QVERIFY(result);
0346     QCOMPARE(storageOffset, changeStarts[7]);
0347     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0348
0349     // 7: end
0350     byteArrayOffset += BaseSize;
0351     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0352     QVERIFY(result);
0353     QCOMPARE(storageOffset, changeStarts[7] + BaseSize - 1);
0354     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0355     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0356     QVERIFY(result);
0357     QCOMPARE(storageOffset, changeStarts[5] + HalfBaseSize);
0358     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0359
0360     // 6: begin
0361     byteArrayOffset += HalfBaseSize;
0362     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0363     QVERIFY(result);
0364     QCOMPARE(storageOffset, changeStarts[5] + BaseSize - 1);
0365     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0366     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0367     QVERIFY(result);
0368     QCOMPARE(storageOffset, changeStarts[6]);
0369     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0370
0371     // 6: end
0372     byteArrayOffset += BaseSize;
0373     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0374     QVERIFY(result);
0375     QCOMPARE(storageOffset, changeStarts[6] + BaseSize - 1);
0376     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0377     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0378     QVERIFY(result);
0379     QCOMPARE(storageOffset, HalfBaseSize);
0380     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0381
0382     // 4: begin
0383     byteArrayOffset += HalfBaseSize;
0384     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0385     QVERIFY(result);
0386     QCOMPARE(storageOffset, BaseSize - 1);
0387     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0388     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0389     QVERIFY(result);
0390     QCOMPARE(storageOffset, changeStarts[4]);
0391     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0392
0393     // 4: end
0394     byteArrayOffset += BaseSize;
0395     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0396     QVERIFY(result);
0397     QCOMPARE(storageOffset, changeStarts[4] + BaseSize - 1);
0398     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0399     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0400     QVERIFY(result);
0401     QCOMPARE(storageOffset, changeStarts[1]);
0402     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0403
0404     // 3: begin
0405     byteArrayOffset += HalfBaseSize;
0406     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0407     QVERIFY(result);
0408     QCOMPARE(storageOffset, changeStarts[1] + HalfBaseSize - 1);
0409     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0410     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0411     QVERIFY(result);
0412     QCOMPARE(storageOffset, changeStarts[3]);
0413     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0414
0415     // 3: end
0416     byteArrayOffset += BaseSize;
0417     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0418     QVERIFY(result);
0419     QCOMPARE(storageOffset, changeStarts[3] + BaseSize - 1);
0420     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0421     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0422     QVERIFY(result);
0423     QCOMPARE(storageOffset, changeStarts[1] + HalfBaseSize);
0424     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0425
0426     // 2: begin
0427     byteArrayOffset += HalfBaseSize;
0428     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0429     QVERIFY(result);
0430     QCOMPARE(storageOffset, changeStarts[1] + BaseSize - 1);
0431     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0432     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0433     QVERIFY(result);
0434     QCOMPARE(storageOffset, changeStarts[2]);
0435     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0436
0437     // 2: end
0438     byteArrayOffset += BaseSize;
0439     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset - 1);
0440     QVERIFY(result);
0441     QCOMPARE(storageOffset, changeStarts[2] + BaseSize - 1);
0442     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0443
0444     result = pieceTable.getStorageData(&storageId, &storageOffset, byteArrayOffset);
0445     QVERIFY(!result);
0446 }
0447
0448 void RevertablePieceTableTest::testRemove()
0449 {
0450     RevertablePieceTable pieceTable;
0451
0452     int changeStarts[6];
0453     int storageId;
0454     int storageOffset;
0455     bool result;
0456
0457     // removing at begin
0458     pieceTable.init(BaseSize);
0459     pieceTable.remove(AddressRange(0, Start - 1));
0460
0461     QCOMPARE(pieceTable.size(), BaseSize - Start);
0462     QCOMPARE(pieceTable.changesCount(), 1);
0463     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0464
0465     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0466     QVERIFY(result);
0467     QCOMPARE(storageOffset, Start);
0468     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0469
0470     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Start - 1);
0471     QVERIFY(result);
0472     QCOMPARE(storageOffset, BaseSize - 1);
0473     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0474
0475     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Start);
0476     QVERIFY(!result);
0477
0478     // removing at middle
0479     pieceTable.init(BaseSize);
0480     pieceTable.remove(AddressRange(Start, End));
0481
0482     QCOMPARE(pieceTable.size(), BaseSize - Width);
0483     QCOMPARE(pieceTable.changesCount(), 1);
0484     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0485
0486     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
0487     QVERIFY(result);
0488     QCOMPARE(storageOffset, Start - 1);
0489     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0490
0491     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
0492     QVERIFY(result);
0493     QCOMPARE(storageOffset, End + 1);
0494     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0495
0496     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Width - 1);
0497     QVERIFY(result);
0498     QCOMPARE(storageOffset, BaseSize - 1);
0499     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0500
0501     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - Width);
0502     QVERIFY(!result);
0503
0504     // removing at end
0505     pieceTable.init(BaseSize);
0506     pieceTable.remove(AddressRange(End + 1, BaseSize - 1));
0507
0508     QCOMPARE(pieceTable.size(), End + 1);
0509     QCOMPARE(pieceTable.changesCount(), 1);
0510     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0511
0512     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
0513     QVERIFY(result);
0514     QCOMPARE(storageOffset, End);
0515     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0516
0517     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
0518     QVERIFY(!result);
0519
0520     // removing all
0521     pieceTable.init(BaseSize);
0522     pieceTable.remove(AddressRange::fromWidth(BaseSize));
0523
0524     QCOMPARE(pieceTable.size(), 0);
0525     QCOMPARE(pieceTable.changesCount(), 1);
0526     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0527
0528     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0529     QVERIFY(!result);
0530
0531     // removing a lot:
0532     const int pieceCount = 5;
0533     const int mid = (pieceCount + 1) / 2;
0534     const int midPieceOffset = BaseSize * (mid - 1);
0535     const int fullSize = pieceCount * BaseSize;
0536     // for this five equally sized pieces are inserted, reverse to offset in ChangeStore
0537     for (int i = 0; i < pieceCount; ++i) {
0538         changeStarts[pieceCount - i] = BaseSize * i;
0539     }
0540
0541     // removing inside a piece in the middle
0542     fillWithSize(&pieceTable, pieceCount);
0543     pieceTable.remove(AddressRange::fromWidth(midPieceOffset + Start, Width));
0544
0545     QCOMPARE(pieceTable.size(), fullSize - Width);
0546     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0547     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0548
0549     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + Start - 1);
0550     QVERIFY(result);
0551     QCOMPARE(storageOffset, changeStarts[mid] + Start - 1);
0552     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0553
0554     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + Start);
0555     QVERIFY(result);
0556     QCOMPARE(storageOffset, changeStarts[mid] + End + 1);
0557     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0558
0559     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Width - 1);
0560     QVERIFY(result);
0561     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0562     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0563
0564     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Width);
0565     QVERIFY(!result);
0566
0567     // removing start of a piece in the middle
0568     fillWithSize(&pieceTable, pieceCount);
0569     pieceTable.remove(AddressRange::fromWidth(midPieceOffset, Start));
0570
0571     QCOMPARE(pieceTable.size(), fullSize - Start);
0572     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0573     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0574
0575     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - 1);
0576     QVERIFY(result);
0577     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - 1);
0578     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0579
0580     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset);
0581     QVERIFY(result);
0582     QCOMPARE(storageOffset, changeStarts[mid] + Start);
0583     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0584
0585     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start - 1);
0586     QVERIFY(result);
0587     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0588     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0589
0590     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start);
0591     QVERIFY(!result);
0592
0593     // removing end of a piece in the middle
0594     fillWithSize(&pieceTable, pieceCount);
0595     pieceTable.remove(AddressRange::fromWidth(midPieceOffset + End + 1, BaseSize - (End + 1)));
0596
0597     QCOMPARE(pieceTable.size(), fullSize - (BaseSize - End - 1));
0598     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0599     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0600
0601     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + End);
0602     QVERIFY(result);
0603     QCOMPARE(storageOffset, changeStarts[mid] + End);
0604     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0605
0606     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset + End + 1);
0607     QVERIFY(result);
0608     QCOMPARE(storageOffset, changeStarts[mid + 1]);
0609     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0610
0611     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - (BaseSize - End - 1) - 1);
0612     QVERIFY(result);
0613     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0614     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0615
0616     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - (BaseSize - End - 1));
0617     QVERIFY(!result);
0618
0619     // removing whole piece in the middle
0620     fillWithSize(&pieceTable, pieceCount);
0621     pieceTable.remove(AddressRange::fromWidth(midPieceOffset, BaseSize));
0622
0623     QCOMPARE(pieceTable.size(), fullSize - BaseSize);
0624     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0625     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0626
0627     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - 1);
0628     QVERIFY(result);
0629     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - 1);
0630     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0631
0632     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset);
0633     QVERIFY(result);
0634     QCOMPARE(storageOffset, changeStarts[mid + 1]);
0635     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0636
0637     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - 1);
0638     QVERIFY(result);
0639     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0640     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0641
0642     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize);
0643     QVERIFY(!result);
0644
0645     // removing whole piece and start of next in the middke
0646     fillWithSize(&pieceTable, pieceCount);
0647     pieceTable.remove(AddressRange::fromWidth(midPieceOffset, BaseSize + Start));
0648
0649     QCOMPARE(pieceTable.size(), fullSize - BaseSize - Start);
0650     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0651     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0652
0653     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - 1);
0654     QVERIFY(result);
0655     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - 1);
0656     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0657
0658     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset);
0659     QVERIFY(result);
0660     QCOMPARE(storageOffset, changeStarts[mid + 1] + Start);
0661     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0662
0663     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start - 1);
0664     QVERIFY(result);
0665     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0666     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0667
0668     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start);
0669     QVERIFY(!result);
0670
0671     // removing whole piece and end of previous in the middle
0672     fillWithSize(&pieceTable, pieceCount);
0673     pieceTable.remove(AddressRange::fromWidth(midPieceOffset - (BaseSize - End - 1), BaseSize + BaseSize - (End + 1)));
0674
0675     QCOMPARE(pieceTable.size(), fullSize - BaseSize - (BaseSize - End - 1));
0676     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0677     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0678
0679     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1) - 1);
0680     QVERIFY(result);
0681     QCOMPARE(storageOffset, changeStarts[mid - 1] + End);
0682     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0683
0684     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1));
0685     QVERIFY(result);
0686     QCOMPARE(storageOffset, changeStarts[mid + 1]);
0687     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0688
0689     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - 1);
0690     QVERIFY(result);
0691     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0692     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0693
0694     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1));
0695     QVERIFY(!result);
0696
0697     // removing end of previous, whole and start of next in the middle
0698     fillWithSize(&pieceTable, pieceCount);
0699     pieceTable.remove(AddressRange::fromWidth(midPieceOffset - (BaseSize - End - 1), Start + BaseSize + BaseSize - (End + 1)));
0700
0701     QCOMPARE(pieceTable.size(), fullSize - BaseSize - (BaseSize - End - 1) - Start);
0702     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0703     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0704
0705     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1) - 1);
0706     QVERIFY(result);
0707     QCOMPARE(storageOffset, changeStarts[mid - 1] + BaseSize - (BaseSize - End - 1) - 1);
0708     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0709
0710     result = pieceTable.getStorageData(&storageId, &storageOffset, midPieceOffset - (BaseSize - End - 1));
0711     QVERIFY(result);
0712     QCOMPARE(storageOffset, changeStarts[mid + 1] + Start);
0713     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0714
0715     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - Start - 1);
0716     QVERIFY(result);
0717     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0718     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0719
0720     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - Start);
0721     QVERIFY(!result);
0722
0723     // removing start of piece at start
0724     fillWithSize(&pieceTable, pieceCount);
0725     pieceTable.remove(AddressRange::fromWidth(Start));
0726
0727     QCOMPARE(pieceTable.size(), fullSize - Start);
0728     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0729     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0730
0731     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0732     QVERIFY(result);
0733     QCOMPARE(storageOffset, changeStarts[1] + Start);
0734     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0735
0736     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start - 1);
0737     QVERIFY(result);
0738     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0739     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0740
0741     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - Start);
0742     QVERIFY(!result);
0743
0744     // removing whole piece at start
0745     fillWithSize(&pieceTable, pieceCount);
0746     pieceTable.remove(AddressRange::fromWidth(BaseSize));
0747
0748     QCOMPARE(pieceTable.size(), fullSize - BaseSize);
0749     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0750     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0751
0752     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0753     QVERIFY(result);
0754     QCOMPARE(storageOffset, changeStarts[2]);
0755     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0756
0757     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - 1);
0758     QVERIFY(result);
0759     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0760     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0761
0762     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize);
0763     QVERIFY(!result);
0764
0765     // removing whole piece and start of next at start
0766     fillWithSize(&pieceTable, pieceCount);
0767     pieceTable.remove(AddressRange::fromWidth(BaseSize + Start));
0768
0769     QCOMPARE(pieceTable.size(), fullSize - BaseSize - Start);
0770     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0771     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0772
0773     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0774     QVERIFY(result);
0775     QCOMPARE(storageOffset, changeStarts[2] + Start);
0776     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0777
0778     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start - 1);
0779     QVERIFY(result);
0780     QCOMPARE(storageOffset, changeStarts[pieceCount] + BaseSize - 1);
0781     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0782
0783     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - Start);
0784     QVERIFY(!result);
0785
0786     // removing end of piece at end
0787     fillWithSize(&pieceTable, pieceCount);
0788     pieceTable.remove(AddressRange::fromWidth(fullSize - BaseSize + End + 1, BaseSize - (End + 1)));
0789
0790     QCOMPARE(pieceTable.size(), fullSize - (BaseSize - End - 1));
0791     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0792     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0793
0794     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize + End);
0795     QVERIFY(result);
0796     QCOMPARE(storageOffset, changeStarts[pieceCount] + End);
0797     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0798
0799     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - (BaseSize - End - 1));
0800     QVERIFY(!result);
0801
0802     // removing whole piece at end
0803     fillWithSize(&pieceTable, pieceCount);
0804     pieceTable.remove(AddressRange::fromWidth(fullSize - BaseSize, BaseSize));
0805
0806     QCOMPARE(pieceTable.size(), fullSize - BaseSize);
0807     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0808     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0809
0810     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - 1);
0811     QVERIFY(result);
0812     QCOMPARE(storageOffset, changeStarts[pieceCount - 1] + BaseSize - 1);
0813     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0814
0815     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize);
0816     QVERIFY(!result);
0817
0818     // removing whole piece and end of previous at end
0819     fillWithSize(&pieceTable, pieceCount);
0820     pieceTable.remove(AddressRange::fromWidth(fullSize - BaseSize - (BaseSize - End - 1), BaseSize + BaseSize - (End + 1)));
0821
0822     QCOMPARE(pieceTable.size(), fullSize - BaseSize - (BaseSize - End - 1));
0823     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0824     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0825
0826     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1) - 1);
0827     QVERIFY(result);
0828     QCOMPARE(storageOffset, changeStarts[pieceCount - 1] + End);
0829     QCOMPARE(storageId, (int)Piece::ChangeStorage);
0830
0831     result = pieceTable.getStorageData(&storageId, &storageOffset, fullSize - BaseSize - (BaseSize - End - 1));
0832     QVERIFY(!result);
0833
0834     // removing all
0835     fillWithSize(&pieceTable, pieceCount);
0836     pieceTable.remove(AddressRange::fromWidth(fullSize));
0837
0838     QCOMPARE(pieceTable.size(), 0);
0839     QCOMPARE(pieceTable.changesCount(), pieceCount + 1);
0840     QCOMPARE(pieceTable.appliedChangesCount(), pieceCount + 1);
0841
0842     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0843     QVERIFY(!result);
0844 }
0845
0846 void RevertablePieceTableTest::testSwap()
0847 {
0848     RevertablePieceTable pieceTable;
0849
0850     int storageId;
0851     int storageOffset;
0852     bool result;
0853
0854     // moving end at begin
0855     pieceTable.init(BaseSize);
0856     pieceTable.swap(0, AddressRange::fromWidth(End + 1, BaseSize - (End + 1)));
0857
0858     QCOMPARE(pieceTable.size(), BaseSize);
0859     QCOMPARE(pieceTable.changesCount(), 1);
0860     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0861
0862     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0863     QVERIFY(result);
0864     QCOMPARE(storageOffset, End + 1);
0865     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0866
0867     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - End - 2);
0868     QVERIFY(result);
0869     QCOMPARE(storageOffset, BaseSize - 1);
0870     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0871
0872     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - End - 1);
0873     QVERIFY(result);
0874     QCOMPARE(storageOffset, 0);
0875     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0876
0877     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
0878     QVERIFY(result);
0879     QCOMPARE(storageOffset, End);
0880     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0881
0882     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
0883     QVERIFY(!result);
0884
0885     // moving end at mid
0886     pieceTable.init(BaseSize);
0887     pieceTable.swap(Start, AddressRange::fromWidth(End + 1, BaseSize - (End + 1)));
0888
0889     QCOMPARE(pieceTable.size(), BaseSize);
0890     QCOMPARE(pieceTable.changesCount(), 1);
0891     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0892
0893     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
0894     QVERIFY(result);
0895     QCOMPARE(storageOffset, Start - 1);
0896     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0897
0898     QCOMPARE(pieceTable.size(), BaseSize);
0899     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
0900     QVERIFY(result);
0901     QCOMPARE(storageOffset, End + 1);
0902     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0903
0904     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + BaseSize - End - 2);
0905     QVERIFY(result);
0906     QCOMPARE(storageOffset, BaseSize - 1);
0907     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0908
0909     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + BaseSize - End - 1);
0910     QVERIFY(result);
0911     QCOMPARE(storageOffset, Start);
0912     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0913
0914     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize - 1);
0915     QVERIFY(result);
0916     QCOMPARE(storageOffset, End);
0917     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0918
0919     result = pieceTable.getStorageData(&storageId, &storageOffset, BaseSize);
0920     QVERIFY(!result);
0921
0922     // moving mid at begin
0923     pieceTable.init(BaseSize);
0924     pieceTable.swap(0, AddressRange::fromWidth(Start, Width));
0925
0926     QCOMPARE(pieceTable.size(), BaseSize);
0927     QCOMPARE(pieceTable.changesCount(), 1);
0928     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0929
0930     QCOMPARE(pieceTable.size(), BaseSize);
0931     result = pieceTable.getStorageData(&storageId, &storageOffset, 0);
0932     QVERIFY(result);
0933     QCOMPARE(storageOffset, Start);
0934     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0935
0936     result = pieceTable.getStorageData(&storageId, &storageOffset, Width - 1);
0937     QVERIFY(result);
0938     QCOMPARE(storageOffset, End);
0939     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0940
0941     result = pieceTable.getStorageData(&storageId, &storageOffset, Width);
0942     QVERIFY(result);
0943     QCOMPARE(storageOffset, 0);
0944     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0945
0946     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
0947     QVERIFY(result);
0948     QCOMPARE(storageOffset, Start - 1);
0949     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0950
0951     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
0952     QVERIFY(result);
0953     QCOMPARE(storageOffset, End + 1);
0954     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0955
0956     // moving mid at mid
0957     pieceTable.init(BaseSize);
0958     int mid = (End + Start) / 2;
0959     pieceTable.swap(Start, AddressRange::fromWidth(mid, End - mid + 1));
0960
0961     QCOMPARE(pieceTable.size(), BaseSize);
0962     QCOMPARE(pieceTable.changesCount(), 1);
0963     QCOMPARE(pieceTable.appliedChangesCount(), 1);
0964
0965     result = pieceTable.getStorageData(&storageId, &storageOffset, Start - 1);
0966     QVERIFY(result);
0967     QCOMPARE(storageOffset, Start - 1);
0968     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0969
0970     result = pieceTable.getStorageData(&storageId, &storageOffset, Start);
0971     QVERIFY(result);
0972     QCOMPARE(storageOffset, mid);
0973     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0974
0975     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + End - mid);
0976     QVERIFY(result);
0977     QCOMPARE(storageOffset, End);
0978     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0979
0980     result = pieceTable.getStorageData(&storageId, &storageOffset, Start + End - mid + 1);
0981     QVERIFY(result);
0982     QCOMPARE(storageOffset, Start);
0983     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0984
0985     result = pieceTable.getStorageData(&storageId, &storageOffset, End);
0986     QVERIFY(result);
0987     QCOMPARE(storageOffset, mid - 1);
0988     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0989
0990     result = pieceTable.getStorageData(&storageId, &storageOffset, End + 1);
0991     QVERIFY(result);
0992     QCOMPARE(storageOffset, End + 1);
0993     QCOMPARE(storageId, (int)Piece::OriginalStorage);
0994
0995     // moving a lot:
0996     const int pieceCount = 5;
0997     const int fullSize = pieceCount * BaseSize;
0998
0999     // 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
1011 #include "moc_revertablepiecetabletest.cpp"