gui/test/bytearraytablecursortest.cpp

0001 /*
0002     This file is part of the Okteta Gui 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 "bytearraytablecursortest.hpp"
0010
0011 // test object
0012 #include <bytearraytablecursor.hpp>
0013 // lib
0014 #include <bytearraytablelayout.hpp>
0015 // Qt
0016 #include <QTest>
0017
0018 namespace Okteta {
0019
0020 // local variables
0021 static constexpr Size NoOfBytesPerLine = 8;
0022 static constexpr Address StartOffset = 22;
0023 static constexpr Address FirstLineOffset = 10;
0024 static constexpr Address RelativeStartOffset = StartOffset - FirstLineOffset;
0025 static constexpr Address ByteArrayOffset = 9;
0026 static constexpr Size Length = 250;
0027
0028 static constexpr Address FirstIndex = ByteArrayOffset;
0029 static constexpr Address LastIndex = Length - 1 + ByteArrayOffset;
0030
0031 static constexpr Line StartLine = RelativeStartOffset / NoOfBytesPerLine;
0032 static constexpr LinePosition StartLinePosition = RelativeStartOffset % NoOfBytesPerLine;
0033 static constexpr Coord StartCoord(StartLinePosition, StartLine);
0034
0035
0036 void ByteArrayTableCursorTest::testConstructor()
0037 {
0038     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0039
0040     ByteArrayTableCursor cursor(&layout);
0041
0042     QCOMPARE(cursor.index(), FirstIndex);
0043     QCOMPARE(cursor.validIndex(), FirstIndex);
0044     QCOMPARE(cursor.realIndex(), FirstIndex);
0045     QCOMPARE(cursor.coord(), StartCoord);
0046     QCOMPARE(cursor.pos(), StartCoord.pos());
0047     QCOMPARE(cursor.line(), StartCoord.line());
0048     QCOMPARE(cursor.isBehind(), false);
0049     QCOMPARE(cursor.appendPosEnabled(), false);
0050     QCOMPARE(cursor.atStart(), true);
0051     QCOMPARE(cursor.atEnd(), false);
0052     QCOMPARE(cursor.atAppendPos(), false);
0053     QCOMPARE(cursor.atLineStart(), true);
0054     QCOMPARE(cursor.atLineEnd(), false);
0055 }
0056
0057 void ByteArrayTableCursorTest::testSetAppendPosEnabled()
0058 {
0059     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0060     const Coord finalCoord = layout.finalCoord();
0061
0062     ByteArrayTableCursor cursor(&layout);
0063
0064     // with append pos
0065     cursor.setAppendPosEnabled(true);
0066     cursor.gotoEnd();
0067
0068     Coord nextToFinalCoord(finalCoord);
0069     nextToFinalCoord.goCRight(layout.noOfBytesPerLine() - 1);
0070     QCOMPARE(cursor.appendPosEnabled(), true);
0071     QCOMPARE(cursor.atAppendPos(), true);
0072     QCOMPARE(cursor.coord(), nextToFinalCoord);
0073
0074     // without append pos
0075     cursor.setAppendPosEnabled(false);
0076     cursor.gotoEnd();
0077     QCOMPARE(cursor.appendPosEnabled(), false);
0078     QCOMPARE(cursor.atAppendPos(), false);
0079     QCOMPARE(cursor.coord(), finalCoord);
0080 }
0081
0082 void ByteArrayTableCursorTest::testGotoIndex()
0083 {
0084     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0085
0086     ByteArrayTableCursor cursor(&layout);
0087
0088     // 2 before first valid, as (in)validIndex equals -1, see next test
0089     Address index = FirstIndex - 2;
0090     Coord coord = layout.coordOfIndex(index);
0091
0092     cursor.gotoIndex(index);
0093
0094     QCOMPARE(cursor.index(), index);
0095     QCOMPARE(cursor.validIndex(), -1);
0096     QCOMPARE(cursor.realIndex(), index);
0097     QCOMPARE(cursor.isBehind(), false);
0098     QCOMPARE(cursor.atStart(), false);
0099     QCOMPARE(cursor.atEnd(), false);
0100     QCOMPARE(cursor.atAppendPos(), false);
0101     QCOMPARE(cursor.atLineStart(), false);
0102     QCOMPARE(cursor.atLineEnd(), false);
0103     QCOMPARE(cursor.coord(), coord);
0104
0105     // 1 before first valid
0106     index = FirstIndex - 1; // hm
0107     coord = layout.coordOfIndex(index);
0108
0109     cursor.gotoIndex(index);
0110
0111     QCOMPARE(cursor.index(), index);
0112     QCOMPARE(cursor.validIndex(), -1);
0113     QCOMPARE(cursor.realIndex(), index);
0114     QCOMPARE(cursor.isBehind(), false);
0115     QCOMPARE(cursor.atStart(), false);
0116     QCOMPARE(cursor.atEnd(), false);
0117     QCOMPARE(cursor.atAppendPos(), false);
0118     QCOMPARE(cursor.atLineStart(), false);
0119     QCOMPARE(cursor.atLineEnd(), false);
0120     QCOMPARE(cursor.coord(), coord);
0121
0122     // at first valid
0123     index = FirstIndex;
0124     coord = layout.coordOfIndex(index);
0125
0126     cursor.gotoIndex(index);
0127
0128     QCOMPARE(cursor.index(), index);
0129     QCOMPARE(cursor.validIndex(), index);
0130     QCOMPARE(cursor.realIndex(), index);
0131     QCOMPARE(cursor.isBehind(), false);
0132     QCOMPARE(cursor.atStart(), true);
0133     QCOMPARE(cursor.atEnd(), false);
0134     QCOMPARE(cursor.atAppendPos(), false);
0135     QCOMPARE(cursor.atLineStart(), true);
0136     QCOMPARE(cursor.atLineEnd(), false);
0137     QCOMPARE(cursor.coord(), coord);
0138
0139     // at last valid
0140     index = LastIndex;
0141     coord = layout.coordOfIndex(index);
0142
0143     cursor.gotoIndex(index);
0144
0145     QCOMPARE(cursor.index(), index);
0146     QCOMPARE(cursor.validIndex(), index);
0147     QCOMPARE(cursor.realIndex(), index);
0148     QCOMPARE(cursor.isBehind(), false);
0149     QCOMPARE(cursor.atStart(), false);
0150     QCOMPARE(cursor.atEnd(), false);
0151     QCOMPARE(cursor.atAppendPos(), false);
0152     QCOMPARE(cursor.atLineStart(), false);
0153     QCOMPARE(cursor.atLineEnd(), true);
0154     QCOMPARE(cursor.coord(), coord);
0155
0156     // 1 after last valid
0157     index = LastIndex + 1;
0158     coord = layout.coordOfIndex(index);
0159
0160     cursor.gotoIndex(index);
0161
0162     QCOMPARE(cursor.index(), index);
0163     QCOMPARE(cursor.validIndex(), -1);
0164     QCOMPARE(cursor.realIndex(), index);
0165     QCOMPARE(cursor.isBehind(), false);
0166     QCOMPARE(cursor.atStart(), false);
0167     QCOMPARE(cursor.atEnd(), true);
0168     QCOMPARE(cursor.atAppendPos(), true);
0169     QCOMPARE(cursor.atLineStart(), false);
0170     QCOMPARE(cursor.atLineEnd(), false);
0171     QCOMPARE(cursor.coord(), coord);
0172
0173     // 2 after last valid
0174     index = LastIndex + 2;
0175     coord = layout.coordOfIndex(index);
0176
0177     cursor.gotoIndex(index);
0178
0179     QCOMPARE(cursor.index(), index);
0180     QCOMPARE(cursor.validIndex(), -1);
0181     QCOMPARE(cursor.realIndex(), index);
0182     QCOMPARE(cursor.isBehind(), false);
0183     QCOMPARE(cursor.atStart(), false);
0184     QCOMPARE(cursor.atEnd(), false);
0185     QCOMPARE(cursor.atAppendPos(), false);
0186     QCOMPARE(cursor.atLineStart(), false);
0187     QCOMPARE(cursor.atLineEnd(), false);
0188     QCOMPARE(cursor.coord(), coord);
0189 }
0190
0191 void ByteArrayTableCursorTest::testGotoCIndex()
0192 {
0193     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0194
0195     ByteArrayTableCursor cursor(&layout);
0196
0197     // 2 before first valid, as (in)validIndex equals -1, see next test
0198     Address index = FirstIndex - 2;
0199     const Coord startCoord = layout.startCoord();
0200
0201     cursor.gotoCIndex(index);
0202
0203     QCOMPARE(cursor.index(), FirstIndex);
0204     QCOMPARE(cursor.validIndex(), FirstIndex);
0205     QCOMPARE(cursor.realIndex(), FirstIndex);
0206     QCOMPARE(cursor.isBehind(), false);
0207     QCOMPARE(cursor.atStart(), true);
0208     QCOMPARE(cursor.atEnd(), false);
0209     QCOMPARE(cursor.atAppendPos(), false);
0210     QCOMPARE(cursor.atLineStart(), true);
0211     QCOMPARE(cursor.atLineEnd(), false);
0212     QCOMPARE(cursor.coord(), startCoord);
0213
0214     // 1 before first valid
0215     index = FirstIndex - 1; // hm
0216
0217     cursor.gotoCIndex(index);
0218
0219     QCOMPARE(cursor.index(), FirstIndex);
0220     QCOMPARE(cursor.validIndex(), FirstIndex);
0221     QCOMPARE(cursor.realIndex(), FirstIndex);
0222     QCOMPARE(cursor.isBehind(), false);
0223     QCOMPARE(cursor.atStart(), true);
0224     QCOMPARE(cursor.atEnd(), false);
0225     QCOMPARE(cursor.atAppendPos(), false);
0226     QCOMPARE(cursor.atLineStart(), true);
0227     QCOMPARE(cursor.atLineEnd(), false);
0228     QCOMPARE(cursor.coord(), startCoord);
0229
0230     // at first valid
0231     index = FirstIndex;
0232     Coord coord = layout.coordOfIndex(index);
0233
0234     cursor.gotoCIndex(index);
0235
0236     QCOMPARE(cursor.index(), index);
0237     QCOMPARE(cursor.validIndex(), index);
0238     QCOMPARE(cursor.realIndex(), index);
0239     QCOMPARE(cursor.isBehind(), false);
0240     QCOMPARE(cursor.atStart(), true);
0241     QCOMPARE(cursor.atEnd(), false);
0242     QCOMPARE(cursor.atAppendPos(), false);
0243     QCOMPARE(cursor.atLineStart(), true);
0244     QCOMPARE(cursor.atLineEnd(), false);
0245     QCOMPARE(cursor.coord(), coord);
0246
0247     // at last valid
0248     index = LastIndex;
0249     coord = layout.coordOfIndex(index);
0250
0251     cursor.gotoCIndex(index);
0252
0253     QCOMPARE(cursor.index(), index);
0254     QCOMPARE(cursor.validIndex(), index);
0255     QCOMPARE(cursor.realIndex(), index);
0256     QCOMPARE(cursor.isBehind(), false);
0257     QCOMPARE(cursor.atStart(), false);
0258     QCOMPARE(cursor.atEnd(), false);
0259     QCOMPARE(cursor.atAppendPos(), false);
0260     QCOMPARE(cursor.atLineStart(), false);
0261     QCOMPARE(cursor.atLineEnd(), true);
0262     QCOMPARE(cursor.coord(), coord);
0263
0264     // 1 after last valid
0265     index = LastIndex + 1;
0266     const Coord finalCoord = layout.finalCoord();
0267
0268     cursor.gotoCIndex(index);
0269
0270     QCOMPARE(cursor.index(), LastIndex);
0271     QCOMPARE(cursor.validIndex(), LastIndex);
0272     QCOMPARE(cursor.realIndex(), index);
0273     QCOMPARE(cursor.isBehind(), true);
0274     QCOMPARE(cursor.atStart(), false);
0275     QCOMPARE(cursor.atEnd(), true);
0276     QCOMPARE(cursor.atAppendPos(), false);
0277     QCOMPARE(cursor.atLineStart(), false);
0278     QCOMPARE(cursor.atLineEnd(), true);
0279     QCOMPARE(cursor.coord(), finalCoord);
0280
0281     // 2 after last valid
0282     index = LastIndex + 2;
0283
0284     cursor.gotoCIndex(index);
0285
0286     QCOMPARE(cursor.index(), LastIndex);
0287     QCOMPARE(cursor.validIndex(), LastIndex);
0288     QCOMPARE(cursor.realIndex(), LastIndex + 1);
0289     QCOMPARE(cursor.isBehind(), true);
0290     QCOMPARE(cursor.atStart(), false);
0291     QCOMPARE(cursor.atEnd(), true);
0292     QCOMPARE(cursor.atAppendPos(), false);
0293     QCOMPARE(cursor.atLineStart(), false);
0294     QCOMPARE(cursor.atLineEnd(), true);
0295     QCOMPARE(cursor.coord(), finalCoord);
0296 }
0297
0298 void ByteArrayTableCursorTest::testGotoRealIndex()
0299 {
0300     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0301
0302     ByteArrayTableCursor cursor(&layout);
0303
0304     // 2 before first valid, as (in)validIndex equals -1, see next test
0305     Address index = FirstIndex;
0306     Coord coord = layout.coordOfIndex(index);
0307     cursor.gotoIndex(index);
0308
0309     cursor.gotoRealIndex();
0310
0311     QCOMPARE(cursor.index(), index);
0312     QCOMPARE(cursor.validIndex(), index);
0313     QCOMPARE(cursor.realIndex(), index);
0314     QCOMPARE(cursor.isBehind(), false);
0315     QCOMPARE(cursor.coord(), coord);
0316
0317     // after gotoLineEnd in first line (so lineEnd != end)
0318     cursor.gotoStart();
0319     cursor.gotoLineEnd();
0320     index = cursor.index() + 1;
0321     coord = layout.coordOfIndex(index);
0322
0323     cursor.gotoRealIndex();
0324
0325     QCOMPARE(cursor.index(), index);
0326     QCOMPARE(cursor.validIndex(), index);
0327     QCOMPARE(cursor.realIndex(), index);
0328     QCOMPARE(cursor.isBehind(), false);
0329     QCOMPARE(cursor.coord(), coord);
0330
0331     // after gotoEnd with append pos disabled
0332     cursor.setAppendPosEnabled(false);
0333     cursor.gotoEnd();
0334     index = cursor.index();
0335     coord = layout.coordOfIndex(index);
0336
0337     cursor.gotoRealIndex();
0338
0339     QCOMPARE(cursor.index(), index);
0340     QCOMPARE(cursor.validIndex(), index);
0341     QCOMPARE(cursor.realIndex(), index + 1);
0342     QCOMPARE(cursor.isBehind(), true);
0343     QCOMPARE(cursor.coord(), coord);
0344
0345     // after gotoEnd with append pos disabled
0346     cursor.setAppendPosEnabled(true);
0347     cursor.gotoEnd();
0348     index = cursor.index();
0349     coord = layout.coordOfIndex(index);
0350
0351     cursor.gotoRealIndex();
0352
0353     QCOMPARE(cursor.index(), index);
0354     QCOMPARE(cursor.validIndex(), -1);
0355     QCOMPARE(cursor.realIndex(), index);
0356     QCOMPARE(cursor.isBehind(), false);
0357     QCOMPARE(cursor.coord(), coord);
0358 }
0359
0360 void ByteArrayTableCursorTest::testGotoStart()
0361 {
0362     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0363     const Coord startCoord = layout.startCoord();
0364
0365     ByteArrayTableCursor cursor(&layout);
0366
0367     cursor.gotoStart();
0368
0369     QCOMPARE(cursor.index(), FirstIndex);
0370     QCOMPARE(cursor.validIndex(), FirstIndex);
0371     QCOMPARE(cursor.realIndex(), FirstIndex);
0372     QCOMPARE(cursor.isBehind(), false);
0373     QCOMPARE(cursor.coord(), startCoord);
0374
0375     // TODO: test for length == 0
0376 }
0377
0378 void ByteArrayTableCursorTest::testGotoEnd()
0379 {
0380     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0381     const Coord finalCoord = layout.finalCoord();
0382
0383     ByteArrayTableCursor cursor(&layout);
0384
0385     // without append pos
0386     cursor.setAppendPosEnabled(false);
0387
0388     cursor.gotoEnd();
0389
0390     QCOMPARE(cursor.index(), LastIndex);
0391     QCOMPARE(cursor.validIndex(), LastIndex);
0392     QCOMPARE(cursor.realIndex(), LastIndex + 1);
0393     QCOMPARE(cursor.isBehind(), true);
0394     QCOMPARE(cursor.coord(), finalCoord);
0395
0396     // without append pos
0397     cursor.setAppendPosEnabled(true);
0398     Coord nextToFinalCoord(finalCoord);
0399     nextToFinalCoord.goCRight(layout.noOfBytesPerLine() - 1);
0400
0401     cursor.gotoEnd();
0402
0403     QCOMPARE(cursor.index(), LastIndex + 1);
0404     QCOMPARE(cursor.validIndex(), -1);
0405     QCOMPARE(cursor.realIndex(), LastIndex + 1);
0406     QCOMPARE(cursor.isBehind(), false);
0407     QCOMPARE(cursor.coord(), nextToFinalCoord);
0408
0409     // TODO: test for length == 0
0410 }
0411
0412 void ByteArrayTableCursorTest::testGotoNextByte()
0413 {
0414     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0415
0416     ByteArrayTableCursor cursor(&layout);
0417
0418     // at start
0419     Address index = FirstIndex + 1;
0420     Coord coord = layout.startCoord();
0421     coord.goCRight(layout.noOfBytesPerLine() - 1);
0422     cursor.gotoStart();
0423
0424     cursor.gotoNextByte();
0425
0426     QCOMPARE(cursor.index(), index);
0427     QCOMPARE(cursor.validIndex(), index);
0428     QCOMPARE(cursor.realIndex(), index);
0429     QCOMPARE(cursor.isBehind(), false);
0430     QCOMPARE(cursor.atStart(), false);
0431     QCOMPARE(cursor.atEnd(), false);
0432     QCOMPARE(cursor.atAppendPos(), false);
0433     QCOMPARE(cursor.atLineStart(), false);
0434     QCOMPARE(cursor.atLineEnd(), false);
0435     QCOMPARE(cursor.coord(), coord);
0436
0437     // one before end
0438     index = LastIndex;
0439     coord = layout.coordOfIndex(index);
0440     cursor.gotoIndex(index - 1);
0441
0442     cursor.gotoNextByte();
0443
0444     QCOMPARE(cursor.index(), index);
0445     QCOMPARE(cursor.validIndex(), index);
0446     QCOMPARE(cursor.realIndex(), index);
0447     QCOMPARE(cursor.isBehind(), false);
0448     QCOMPARE(cursor.atStart(), false);
0449     QCOMPARE(cursor.atEnd(), false);
0450     QCOMPARE(cursor.atAppendPos(), false);
0451     QCOMPARE(cursor.atLineStart(), false);
0452     QCOMPARE(cursor.atLineEnd(), true);
0453     QCOMPARE(cursor.coord(), coord);
0454
0455     // at end, append disabled -> noop
0456     cursor.setAppendPosEnabled(false);
0457     cursor.gotoEnd();
0458     index = cursor.index();
0459     coord = cursor.coord();
0460     bool isBehind = cursor.isBehind();
0461
0462     cursor.gotoNextByte();
0463
0464     QCOMPARE(cursor.index(), index);
0465     QCOMPARE(cursor.validIndex(), index);
0466     QCOMPARE(cursor.realIndex(), index + 1);
0467     QCOMPARE(cursor.isBehind(), isBehind);
0468     QCOMPARE(cursor.atStart(), false);
0469     QCOMPARE(cursor.atEnd(), true);
0470     QCOMPARE(cursor.atAppendPos(), false);
0471     QCOMPARE(cursor.atLineStart(), false);
0472     QCOMPARE(cursor.atLineEnd(), true);
0473     QCOMPARE(cursor.coord(), coord);
0474
0475     // at end, append enabled -> noop
0476     cursor.setAppendPosEnabled(true);
0477     cursor.gotoEnd();
0478     index = cursor.index();
0479     coord = cursor.coord();
0480     isBehind = cursor.isBehind();
0481
0482     cursor.gotoNextByte();
0483
0484     QCOMPARE(cursor.index(), index);
0485     QCOMPARE(cursor.validIndex(), -1);
0486     QCOMPARE(cursor.realIndex(), index);
0487     QCOMPARE(cursor.isBehind(), isBehind);
0488     QCOMPARE(cursor.atStart(), false);
0489     QCOMPARE(cursor.atEnd(), true);
0490     QCOMPARE(cursor.atAppendPos(), true);
0491     QCOMPARE(cursor.atLineStart(), false);
0492     QCOMPARE(cursor.atLineEnd(), false);
0493     QCOMPARE(cursor.coord(), coord);
0494 }
0495
0496 void ByteArrayTableCursorTest::testGotoPreviousByte()
0497 {
0498     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0499
0500     ByteArrayTableCursor cursor(&layout);
0501
0502     // at start
0503     cursor.gotoStart();
0504     Address index = cursor.index();
0505     Coord coord = cursor.coord();
0506
0507     cursor.gotoPreviousByte();
0508
0509     QCOMPARE(cursor.index(), index);
0510     QCOMPARE(cursor.validIndex(), index);
0511     QCOMPARE(cursor.realIndex(), index);
0512     QCOMPARE(cursor.isBehind(), false);
0513     QCOMPARE(cursor.atStart(), true);
0514     QCOMPARE(cursor.atEnd(), false);
0515     QCOMPARE(cursor.atAppendPos(), false);
0516     QCOMPARE(cursor.atLineStart(), true);
0517     QCOMPARE(cursor.atLineEnd(), false);
0518     QCOMPARE(cursor.coord(), coord);
0519
0520     // one after start
0521     index = FirstIndex;
0522     coord = layout.coordOfIndex(index);
0523     cursor.gotoIndex(index + 1);
0524
0525     cursor.gotoPreviousByte();
0526
0527     QCOMPARE(cursor.index(), index);
0528     QCOMPARE(cursor.validIndex(), index);
0529     QCOMPARE(cursor.realIndex(), index);
0530     QCOMPARE(cursor.isBehind(), false);
0531     QCOMPARE(cursor.atStart(), true);
0532     QCOMPARE(cursor.atEnd(), false);
0533     QCOMPARE(cursor.atAppendPos(), false);
0534     QCOMPARE(cursor.atLineStart(), true);
0535     QCOMPARE(cursor.atLineEnd(), false);
0536     QCOMPARE(cursor.coord(), coord);
0537
0538     // at end, append disabled -> noop
0539     cursor.setAppendPosEnabled(false);
0540     cursor.gotoEnd();
0541     index = cursor.realIndex() - 1;
0542     coord = layout.coordOfIndex(index);
0543
0544     cursor.gotoPreviousByte();
0545
0546     QCOMPARE(cursor.index(), index);
0547     QCOMPARE(cursor.validIndex(), index);
0548     QCOMPARE(cursor.realIndex(), index);
0549     QCOMPARE(cursor.isBehind(), false);
0550     QCOMPARE(cursor.atStart(), false);
0551     QCOMPARE(cursor.atEnd(), false);
0552     QCOMPARE(cursor.atAppendPos(), false);
0553     QCOMPARE(cursor.atLineStart(), false);
0554     QCOMPARE(cursor.atLineEnd(), true);
0555     QCOMPARE(cursor.coord(), coord);
0556
0557     // at end, append enabled -> noop
0558     cursor.setAppendPosEnabled(true);
0559     cursor.gotoEnd();
0560     index = cursor.realIndex() - 1;
0561     coord = layout.coordOfIndex(index);
0562
0563     cursor.gotoPreviousByte();
0564
0565     QCOMPARE(cursor.index(), index);
0566     QCOMPARE(cursor.validIndex(), index);
0567     QCOMPARE(cursor.realIndex(), index);
0568     QCOMPARE(cursor.isBehind(), false);
0569     QCOMPARE(cursor.atStart(), false);
0570     QCOMPARE(cursor.atEnd(), false);
0571     QCOMPARE(cursor.atAppendPos(), false);
0572     QCOMPARE(cursor.atLineStart(), false);
0573     QCOMPARE(cursor.atLineEnd(), true);
0574     QCOMPARE(cursor.coord(), coord);
0575 }
0576
0577 void ByteArrayTableCursorTest::testGotoNextByteN()
0578 {
0579     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0580
0581     ByteArrayTableCursor cursor(&layout);
0582
0583     // at start
0584     // one right
0585     Address indexSteps = 1;
0586     Address expectedIndex = FirstIndex + indexSteps;
0587     Coord expectedCoord = layout.coordOfIndex(expectedIndex);
0588     cursor.gotoStart();
0589
0590     cursor.gotoNextByte(indexSteps);
0591
0592     QCOMPARE(cursor.index(), expectedIndex);
0593     QCOMPARE(cursor.validIndex(), expectedIndex);
0594     QCOMPARE(cursor.realIndex(), expectedIndex);
0595     QCOMPARE(cursor.isBehind(), false);
0596     QCOMPARE(cursor.atStart(), false);
0597     QCOMPARE(cursor.atEnd(), false);
0598     QCOMPARE(cursor.atAppendPos(), false);
0599     QCOMPARE(cursor.atLineStart(), false);
0600     QCOMPARE(cursor.atLineEnd(), false);
0601     QCOMPARE(cursor.coord(), expectedCoord);
0602
0603     // one line
0604     indexSteps = layout.noOfBytesPerLine();
0605     expectedIndex = FirstIndex + indexSteps;
0606     expectedCoord = layout.coordOfIndex(expectedIndex);
0607     cursor.gotoStart();
0608
0609     cursor.gotoNextByte(indexSteps);
0610
0611     QCOMPARE(cursor.index(), expectedIndex);
0612     QCOMPARE(cursor.validIndex(), expectedIndex);
0613     QCOMPARE(cursor.realIndex(), expectedIndex);
0614     QCOMPARE(cursor.isBehind(), false);
0615     QCOMPARE(cursor.atStart(), false);
0616     QCOMPARE(cursor.atEnd(), false);
0617     QCOMPARE(cursor.atAppendPos(), false);
0618     QCOMPARE(cursor.atLineStart(), false);
0619     QCOMPARE(cursor.atLineEnd(), false);
0620     QCOMPARE(cursor.coord(), expectedCoord);
0621
0622     // to end, append disabled
0623     cursor.setAppendPosEnabled(false);
0624     indexSteps = layout.length();
0625     expectedIndex = FirstIndex + indexSteps - 1;
0626     expectedCoord = layout.coordOfIndex(expectedIndex);
0627     cursor.gotoStart();
0628
0629     cursor.gotoNextByte(indexSteps);
0630
0631     QCOMPARE(cursor.index(), expectedIndex);
0632     QCOMPARE(cursor.validIndex(), expectedIndex);
0633     QCOMPARE(cursor.realIndex(), expectedIndex + 1);
0634     QCOMPARE(cursor.isBehind(), true);
0635     QCOMPARE(cursor.atStart(), false);
0636     QCOMPARE(cursor.atEnd(), true);
0637     QCOMPARE(cursor.atAppendPos(), false);
0638     QCOMPARE(cursor.atLineStart(), false);
0639     QCOMPARE(cursor.atLineEnd(), true);
0640     QCOMPARE(cursor.coord(), expectedCoord);
0641
0642     // to end, append disabled
0643     cursor.setAppendPosEnabled(true);
0644     indexSteps = layout.length();
0645     expectedIndex = FirstIndex + indexSteps;
0646     expectedCoord = layout.coordOfIndex(expectedIndex);
0647     cursor.gotoStart();
0648
0649     cursor.gotoNextByte(indexSteps);
0650
0651     QCOMPARE(cursor.index(), expectedIndex);
0652     QCOMPARE(cursor.validIndex(), -1);
0653     QCOMPARE(cursor.realIndex(), expectedIndex);
0654     QCOMPARE(cursor.isBehind(), false);
0655     QCOMPARE(cursor.atStart(), false);
0656     QCOMPARE(cursor.atEnd(), true);
0657     QCOMPARE(cursor.atAppendPos(), true);
0658     QCOMPARE(cursor.atLineStart(), false);
0659     QCOMPARE(cursor.atLineEnd(), false);
0660     QCOMPARE(cursor.coord(), expectedCoord);
0661
0662     // behind end, append disabled
0663     cursor.setAppendPosEnabled(false);
0664     indexSteps = layout.length() + 1;
0665     expectedIndex = LastIndex;
0666     expectedCoord = layout.coordOfIndex(expectedIndex);
0667     cursor.gotoStart();
0668
0669     cursor.gotoNextByte(indexSteps);
0670
0671     QCOMPARE(cursor.index(), expectedIndex);
0672     QCOMPARE(cursor.validIndex(), expectedIndex);
0673     QCOMPARE(cursor.realIndex(), expectedIndex + 1);
0674     QCOMPARE(cursor.isBehind(), true);
0675     QCOMPARE(cursor.atStart(), false);
0676     QCOMPARE(cursor.atEnd(), true);
0677     QCOMPARE(cursor.atAppendPos(), false);
0678     QCOMPARE(cursor.atLineStart(), false);
0679     QCOMPARE(cursor.atLineEnd(), true);
0680     QCOMPARE(cursor.coord(), expectedCoord);
0681
0682     // behind end, append disabled
0683     cursor.setAppendPosEnabled(true);
0684     indexSteps = layout.length() + 1;
0685     expectedIndex = LastIndex + 1;
0686     expectedCoord = layout.coordOfIndex(expectedIndex);
0687     cursor.gotoStart();
0688
0689     cursor.gotoNextByte(indexSteps);
0690
0691     QCOMPARE(cursor.index(), expectedIndex);
0692     QCOMPARE(cursor.validIndex(), -1);
0693     QCOMPARE(cursor.realIndex(), expectedIndex);
0694     QCOMPARE(cursor.isBehind(), false);
0695     QCOMPARE(cursor.atStart(), false);
0696     QCOMPARE(cursor.atEnd(), true);
0697     QCOMPARE(cursor.atAppendPos(), true);
0698     QCOMPARE(cursor.atLineStart(), false);
0699     QCOMPARE(cursor.atLineEnd(), false);
0700     QCOMPARE(cursor.coord(), expectedCoord);
0701
0702     // one before end
0703     // to end
0704     indexSteps = 1;
0705     expectedIndex = LastIndex;
0706     expectedCoord = layout.coordOfIndex(expectedIndex);
0707     cursor.gotoIndex(LastIndex - 1);
0708
0709     cursor.gotoNextByte(indexSteps);
0710
0711     QCOMPARE(cursor.index(), expectedIndex);
0712     QCOMPARE(cursor.validIndex(), expectedIndex);
0713     QCOMPARE(cursor.realIndex(), expectedIndex);
0714     QCOMPARE(cursor.isBehind(), false);
0715     QCOMPARE(cursor.atStart(), false);
0716     QCOMPARE(cursor.atEnd(), false);
0717     QCOMPARE(cursor.atAppendPos(), false);
0718     QCOMPARE(cursor.atLineStart(), false);
0719     QCOMPARE(cursor.atLineEnd(), true);
0720     QCOMPARE(cursor.coord(), expectedCoord);
0721
0722     // behind end, append disabled
0723     cursor.setAppendPosEnabled(false);
0724     indexSteps = 2;
0725     expectedIndex = LastIndex;
0726     expectedCoord = layout.coordOfIndex(expectedIndex);
0727     cursor.gotoIndex(LastIndex - 1);
0728
0729     cursor.gotoNextByte(indexSteps);
0730
0731     QCOMPARE(cursor.index(), expectedIndex);
0732     QCOMPARE(cursor.validIndex(), expectedIndex);
0733     QCOMPARE(cursor.realIndex(), expectedIndex + 1);
0734     QCOMPARE(cursor.isBehind(), true);
0735     QCOMPARE(cursor.atStart(), false);
0736     QCOMPARE(cursor.atEnd(), true);
0737     QCOMPARE(cursor.atAppendPos(), false);
0738     QCOMPARE(cursor.atLineStart(), false);
0739     QCOMPARE(cursor.atLineEnd(), true);
0740     QCOMPARE(cursor.coord(), expectedCoord);
0741
0742     // behind end, append disabled
0743     cursor.setAppendPosEnabled(true);
0744     indexSteps = 2;
0745     expectedIndex = LastIndex + 1;
0746     expectedCoord = layout.coordOfIndex(expectedIndex);
0747     cursor.gotoIndex(LastIndex - 1);
0748
0749     cursor.gotoNextByte(indexSteps);
0750
0751     QCOMPARE(cursor.index(), expectedIndex);
0752     QCOMPARE(cursor.validIndex(), -1);
0753     QCOMPARE(cursor.realIndex(), expectedIndex);
0754     QCOMPARE(cursor.isBehind(), false);
0755     QCOMPARE(cursor.atStart(), false);
0756     QCOMPARE(cursor.atEnd(), true);
0757     QCOMPARE(cursor.atAppendPos(), true);
0758     QCOMPARE(cursor.atLineStart(), false);
0759     QCOMPARE(cursor.atLineEnd(), false);
0760     QCOMPARE(cursor.coord(), expectedCoord);
0761
0762     // at end
0763     // TODO: check for end == lineEnd
0764     // append disabled -> noop
0765     cursor.setAppendPosEnabled(false);
0766     indexSteps = 1;
0767     expectedIndex = LastIndex;
0768     expectedCoord = layout.coordOfIndex(expectedIndex);
0769     cursor.gotoEnd();
0770
0771     cursor.gotoNextByte(indexSteps);
0772
0773     QCOMPARE(cursor.index(), expectedIndex);
0774     QCOMPARE(cursor.validIndex(), expectedIndex);
0775     QCOMPARE(cursor.realIndex(), expectedIndex + 1);
0776     QCOMPARE(cursor.isBehind(), true);
0777     QCOMPARE(cursor.atStart(), false);
0778     QCOMPARE(cursor.atEnd(), true);
0779     QCOMPARE(cursor.atAppendPos(), false);
0780     QCOMPARE(cursor.atLineStart(), false);
0781     QCOMPARE(cursor.atLineEnd(), true);
0782     QCOMPARE(cursor.coord(), expectedCoord);
0783
0784     // append enabled -> noop
0785     cursor.setAppendPosEnabled(true);
0786     indexSteps = 1;
0787     expectedIndex = LastIndex + 1;
0788     expectedCoord = layout.coordOfIndex(expectedIndex);
0789     cursor.gotoEnd();
0790
0791     cursor.gotoNextByte(indexSteps);
0792
0793     QCOMPARE(cursor.index(), expectedIndex);
0794     QCOMPARE(cursor.validIndex(), -1);
0795     QCOMPARE(cursor.realIndex(), expectedIndex);
0796     QCOMPARE(cursor.isBehind(), false);
0797     QCOMPARE(cursor.atStart(), false);
0798     QCOMPARE(cursor.atEnd(), true);
0799     QCOMPARE(cursor.atAppendPos(), true);
0800     QCOMPARE(cursor.atLineStart(), false);
0801     QCOMPARE(cursor.atLineEnd(), false);
0802     QCOMPARE(cursor.coord(), expectedCoord);
0803 }
0804
0805 void ByteArrayTableCursorTest::testGotoPreviousByteN()
0806 {
0807     const ByteArrayTableLayout layout(NoOfBytesPerLine, FirstLineOffset, StartOffset, ByteArrayOffset, Length);
0808
0809     ByteArrayTableCursor cursor(&layout);
0810
0811     // at start
0812     Address indexSteps = 1;
0813     Address expectedIndex = FirstIndex;
0814     Coord expectedCoord = layout.coordOfIndex(expectedIndex);
0815     cursor.gotoStart();
0816
0817     cursor.gotoPreviousByte(indexSteps);
0818
0819     QCOMPARE(cursor.index(), expectedIndex);
0820     QCOMPARE(cursor.validIndex(), expectedIndex);
0821     QCOMPARE(cursor.realIndex(), expectedIndex);
0822     QCOMPARE(cursor.isBehind(), false);
0823     QCOMPARE(cursor.atStart(), true);
0824     QCOMPARE(cursor.atEnd(), false);
0825     QCOMPARE(cursor.atAppendPos(), false);
0826     QCOMPARE(cursor.atLineStart(), true);
0827     QCOMPARE(cursor.atLineEnd(), false);
0828     QCOMPARE(cursor.coord(), expectedCoord);
0829
0830     // one behind start
0831     // to start
0832     indexSteps = 1;
0833     expectedIndex = FirstIndex;
0834     expectedCoord = layout.coordOfIndex(expectedIndex);
0835     cursor.gotoIndex(FirstIndex + 1);
0836
0837     cursor.gotoPreviousByte(indexSteps);
0838
0839     QCOMPARE(cursor.index(), expectedIndex);
0840     QCOMPARE(cursor.validIndex(), expectedIndex);
0841     QCOMPARE(cursor.realIndex(), expectedIndex);
0842     QCOMPARE(cursor.isBehind(), false);
0843     QCOMPARE(cursor.atStart(), true);
0844     QCOMPARE(cursor.atEnd(), false);
0845     QCOMPARE(cursor.atAppendPos(), false);
0846     QCOMPARE(cursor.atLineStart(), true);
0847     QCOMPARE(cursor.atLineEnd(), false);
0848     QCOMPARE(cursor.coord(), expectedCoord);
0849
0850     // to one before start
0851     indexSteps = 2;
0852     expectedIndex = FirstIndex;
0853     expectedCoord = layout.coordOfIndex(expectedIndex);
0854     cursor.gotoIndex(FirstIndex + 1);
0855
0856     cursor.gotoPreviousByte(indexSteps);
0857
0858     QCOMPARE(cursor.index(), expectedIndex);
0859     QCOMPARE(cursor.validIndex(), expectedIndex);
0860     QCOMPARE(cursor.realIndex(), expectedIndex);
0861     QCOMPARE(cursor.isBehind(), false);
0862     QCOMPARE(cursor.atStart(), true);
0863     QCOMPARE(cursor.atEnd(), false);
0864     QCOMPARE(cursor.atAppendPos(), false);
0865     QCOMPARE(cursor.atLineStart(), true);
0866     QCOMPARE(cursor.atLineEnd(), false);
0867     QCOMPARE(cursor.coord(), expectedCoord);
0868
0869     // at end
0870     // append disabled -> noop
0871     cursor.setAppendPosEnabled(false);
0872     // to start
0873     indexSteps = layout.length();
0874     expectedIndex = FirstIndex;
0875     expectedCoord = layout.coordOfIndex(expectedIndex);
0876     cursor.gotoEnd();
0877
0878     cursor.gotoPreviousByte(indexSteps);
0879
0880     QCOMPARE(cursor.index(), expectedIndex);
0881     QCOMPARE(cursor.validIndex(), expectedIndex);
0882     QCOMPARE(cursor.realIndex(), expectedIndex);
0883     QCOMPARE(cursor.isBehind(), false);
0884     QCOMPARE(cursor.atStart(), true);
0885     QCOMPARE(cursor.atEnd(), false);
0886     QCOMPARE(cursor.atAppendPos(), false);
0887     QCOMPARE(cursor.atLineStart(), true);
0888     QCOMPARE(cursor.atLineEnd(), false);
0889     QCOMPARE(cursor.coord(), expectedCoord);
0890
0891     // to one before start
0892     indexSteps = layout.length() + 1;
0893     expectedIndex = FirstIndex;
0894     expectedCoord = layout.coordOfIndex(expectedIndex);
0895     cursor.gotoEnd();
0896
0897     cursor.gotoPreviousByte(indexSteps);
0898
0899     QCOMPARE(cursor.index(), expectedIndex);
0900     QCOMPARE(cursor.validIndex(), expectedIndex);
0901     QCOMPARE(cursor.realIndex(), expectedIndex);
0902     QCOMPARE(cursor.isBehind(), false);
0903     QCOMPARE(cursor.atStart(), true);
0904     QCOMPARE(cursor.atEnd(), false);
0905     QCOMPARE(cursor.atAppendPos(), false);
0906     QCOMPARE(cursor.atLineStart(), true);
0907     QCOMPARE(cursor.atLineEnd(), false);
0908     QCOMPARE(cursor.coord(), expectedCoord);
0909
0910     // append disabled -> noop
0911     cursor.setAppendPosEnabled(true);
0912     // to start
0913     indexSteps = layout.length();
0914     expectedIndex = FirstIndex;
0915     expectedCoord = layout.coordOfIndex(expectedIndex);
0916     cursor.gotoEnd();
0917
0918     cursor.gotoPreviousByte(indexSteps);
0919
0920     QCOMPARE(cursor.index(), expectedIndex);
0921     QCOMPARE(cursor.validIndex(), expectedIndex);
0922     QCOMPARE(cursor.realIndex(), expectedIndex);
0923     QCOMPARE(cursor.isBehind(), false);
0924     QCOMPARE(cursor.atStart(), true);
0925     QCOMPARE(cursor.atEnd(), false);
0926     QCOMPARE(cursor.atAppendPos(), false);
0927     QCOMPARE(cursor.atLineStart(), true);
0928     QCOMPARE(cursor.atLineEnd(), false);
0929     QCOMPARE(cursor.coord(), expectedCoord);
0930
0931     // to one before start
0932     indexSteps = layout.length() + 1;
0933     expectedIndex = FirstIndex;
0934     expectedCoord = layout.coordOfIndex(expectedIndex);
0935     cursor.gotoEnd();
0936
0937     cursor.gotoPreviousByte(indexSteps);
0938
0939     QCOMPARE(cursor.index(), expectedIndex);
0940     QCOMPARE(cursor.validIndex(), expectedIndex);
0941     QCOMPARE(cursor.realIndex(), expectedIndex);
0942     QCOMPARE(cursor.isBehind(), false);
0943     QCOMPARE(cursor.atStart(), true);
0944     QCOMPARE(cursor.atEnd(), false);
0945     QCOMPARE(cursor.atAppendPos(), false);
0946     QCOMPARE(cursor.atLineStart(), true);
0947     QCOMPARE(cursor.atLineEnd(), false);
0948     QCOMPARE(cursor.coord(), expectedCoord);
0949 }
0950
0951 }
0952
0953 QTEST_MAIN(Okteta::ByteArrayTableCursorTest)
0954
0955 #include "moc_bytearraytablecursortest.cpp"