File indexing completed on 2024-04-28 05:52:31
0001 /* 0002 This file is part of the Okteta Core library, made within the KDE community. 0003 0004 SPDX-FileCopyrightText: 2006 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 "abstractbytearraymodeliftest.hpp" 0010 0011 // test object 0012 #include <fixedsizebytearraymodel.hpp> 0013 // test util 0014 #include <util/fill.hpp> 0015 // lib 0016 #include <arraychangemetricslist.hpp> 0017 // Qt 0018 #include <QTest> 0019 #include <QSignalSpy> 0020 0021 Q_DECLARE_METATYPE(Okteta::ArrayChangeMetricsList) 0022 0023 namespace Okteta { 0024 0025 bool AbstractByteArrayModelIfTest::byteArrayModelSizeCanBeChanged() const 0026 { 0027 return true; 0028 } 0029 0030 //---------------------------------------------------------------- Tests ----- 0031 0032 void AbstractByteArrayModelIfTest::init() 0033 { 0034 mByteArrayModel = createByteArrayModel(); 0035 0036 qRegisterMetaType<ArrayChangeMetricsList>("Okteta::ArrayChangeMetricsList"); 0037 ContentsChangeListSpy = new QSignalSpy(mByteArrayModel, SIGNAL(contentsChanged(Okteta::ArrayChangeMetricsList))); 0038 } 0039 0040 void AbstractByteArrayModelIfTest::cleanup() 0041 { 0042 deleteByteArrayModel(mByteArrayModel); 0043 0044 delete ContentsChangeListSpy; 0045 } 0046 0047 void AbstractByteArrayModelIfTest::clearSignalSpys() 0048 { 0049 ContentsChangeListSpy->clear(); 0050 } 0051 0052 void AbstractByteArrayModelIfTest::checkContentsReplaced(Address offset, Size removeLength, int insertLength) 0053 { 0054 QVERIFY(ContentsChangeListSpy->isValid()); 0055 QCOMPARE(ContentsChangeListSpy->size(), 1); 0056 const QList<QVariant> arguments = ContentsChangeListSpy->takeFirst(); 0057 const ArrayChangeMetrics changeMetrics = (qvariant_cast<ArrayChangeMetricsList>(arguments.at(0))).at(0); 0058 QCOMPARE(changeMetrics.offset(), offset); 0059 QCOMPARE(changeMetrics.removeLength(), removeLength); 0060 QCOMPARE(changeMetrics.insertLength(), insertLength); 0061 } 0062 void AbstractByteArrayModelIfTest::checkContentsReplaced(const AddressRange& removeRange, int insertLength) 0063 { checkContentsReplaced(removeRange.start(), removeRange.width(), insertLength); } 0064 0065 void AbstractByteArrayModelIfTest::checkContentsSwapped(Address firstStart, Address secondStart, Size secondLength) 0066 { 0067 QVERIFY(ContentsChangeListSpy->isValid()); 0068 QCOMPARE(ContentsChangeListSpy->size(), 1); 0069 const QList<QVariant> arguments = ContentsChangeListSpy->takeFirst(); 0070 const ArrayChangeMetrics changeMetrics = (qvariant_cast<ArrayChangeMetricsList>(arguments.at(0))).at(0); 0071 QCOMPARE(changeMetrics.offset(), firstStart); 0072 QCOMPARE(changeMetrics.secondStart(), secondStart); 0073 QCOMPARE(changeMetrics.secondLength(), secondLength); 0074 } 0075 void AbstractByteArrayModelIfTest::checkContentsSwapped(Address firstStart, const AddressRange& secondSection) 0076 { checkContentsSwapped(firstStart, secondSection.start(), secondSection.width()); } 0077 0078 //---------------------------------------------------------------- Tests ----- 0079 0080 void AbstractByteArrayModelIfTest::testModified() 0081 { 0082 // can we alter the buffer at all? 0083 if (mByteArrayModel->isReadOnly()) { 0084 // skip 0085 return; 0086 } 0087 0088 mByteArrayModel->setModified(false); 0089 QVERIFY(!mByteArrayModel->isModified()); 0090 mByteArrayModel->setModified(true); 0091 QVERIFY(mByteArrayModel->isModified()); 0092 } 0093 0094 // TODO: test all edit operations to be blocked, but in their tests 0095 void AbstractByteArrayModelIfTest::testSetReadOnly() 0096 { 0097 // can we alter the buffer at all? 0098 if (mByteArrayModel->isReadOnly()) { 0099 // skip 0100 return; 0101 } 0102 0103 mByteArrayModel->setReadOnly(true); 0104 QVERIFY(mByteArrayModel->isReadOnly()); 0105 0106 mByteArrayModel->setReadOnly(false); 0107 QVERIFY(!mByteArrayModel->isReadOnly()); 0108 } 0109 0110 void AbstractByteArrayModelIfTest::testCopyTo() 0111 { 0112 if (!mByteArrayModel->isReadOnly()) { 0113 // prepare mByteArrayModel 0114 textureByteArrayModel(mByteArrayModel); 0115 mByteArrayModel->setModified(false); 0116 } 0117 0118 // 0119 constexpr Size copySize = 10; 0120 Size size = mByteArrayModel->size(); 0121 AddressRange copyRange(0, copySize - 1); 0122 0123 FixedSizeByteArrayModel copy(size, BlankChar); 0124 // copyTo() all 0125 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0126 QCOMPARE(copy.compare(*mByteArrayModel), 0); 0127 0128 // copyTo() at begin 0129 copy.fill(BlankChar); 0130 0131 mByteArrayModel->copyTo(copy.rawData(), copyRange); 0132 0133 QCOMPARE(copy.compare(*mByteArrayModel, copyRange), 0); 0134 QCOMPARE(copy.byte(copyRange.nextBehindEnd()), BlankChar); 0135 QVERIFY(!mByteArrayModel->isModified()); 0136 0137 // copyTo() at end 0138 copy.fill(BlankChar); 0139 copyRange.moveToEnd(size - 1); 0140 0141 mByteArrayModel->copyTo(©.rawData()[copyRange.start()], copyRange); 0142 0143 QCOMPARE(copy.byte(copyRange.nextBeforeStart()), BlankChar); 0144 QCOMPARE(copy.compare(*mByteArrayModel, copyRange, copyRange.start()), 0); 0145 QVERIFY(!mByteArrayModel->isModified()); 0146 0147 // copyTo() at mid 0148 copy.fill(BlankChar); 0149 copyRange.moveToStart(size / 2); 0150 0151 mByteArrayModel->copyTo(©.rawData()[copyRange.start()], copyRange); 0152 0153 QCOMPARE(copy.byte(copyRange.nextBeforeStart()), BlankChar); 0154 QCOMPARE(copy.compare(*mByteArrayModel, copyRange, copyRange.start()), 0); 0155 QCOMPARE(copy.byte(copyRange.nextBehindEnd()), BlankChar); 0156 QVERIFY(!mByteArrayModel->isModified()); 0157 } 0158 0159 void AbstractByteArrayModelIfTest::testFill() 0160 { 0161 // can we alter the buffer at all? 0162 if (mByteArrayModel->isReadOnly()) { 0163 // skip 0164 return; 0165 } 0166 0167 constexpr Size fillSize = 10; 0168 Size size = mByteArrayModel->size(); 0169 AddressRange fillRange = AddressRange::fromWidth(0, size); 0170 0171 FixedSizeByteArrayModel copy(size, PaintChar); 0172 0173 // fill() all 0174 mByteArrayModel->setModified(false); 0175 mByteArrayModel->fill(BlankChar); 0176 clearSignalSpys(); 0177 0178 mByteArrayModel->fill(PaintChar); 0179 QCOMPARE(copy.compare(*mByteArrayModel), 0); 0180 QVERIFY(mByteArrayModel->isModified()); 0181 checkContentsReplaced(fillRange, fillRange.width()); 0182 0183 // fill() at begin 0184 fillRange.set(0, fillSize); 0185 mByteArrayModel->setModified(false); 0186 mByteArrayModel->fill(BlankChar); 0187 clearSignalSpys(); 0188 0189 mByteArrayModel->fill(PaintChar, fillRange); 0190 QCOMPARE(copy.compare(*mByteArrayModel, fillRange), 0); 0191 QCOMPARE(mByteArrayModel->byte(fillRange.nextBehindEnd()), BlankChar); 0192 QVERIFY(mByteArrayModel->isModified()); 0193 checkContentsReplaced(fillRange, fillRange.width()); 0194 0195 // fill() at end 0196 mByteArrayModel->setModified(false); 0197 mByteArrayModel->fill(BlankChar); 0198 fillRange.moveToEnd(size - 1); 0199 clearSignalSpys(); 0200 0201 mByteArrayModel->fill(PaintChar, fillRange); 0202 QCOMPARE(mByteArrayModel->byte(fillRange.nextBeforeStart()), BlankChar); 0203 QCOMPARE(copy.compare(*mByteArrayModel, fillRange, fillRange.start()), 0); 0204 QVERIFY(mByteArrayModel->isModified()); 0205 checkContentsReplaced(fillRange, fillRange.width()); 0206 0207 // fill() at end with length reaching behind end 0208 constexpr Size behindEndSize = 2; 0209 mByteArrayModel->setModified(false); 0210 mByteArrayModel->fill(BlankChar); 0211 fillRange.moveToEnd(size - 1 + behindEndSize); 0212 clearSignalSpys(); 0213 0214 mByteArrayModel->fill(PaintChar, fillRange.start(), fillRange.width()); 0215 const AddressRange removedRange(fillRange.start(), size - 1); 0216 const AddressRange insertedRange = byteArrayModelSizeCanBeChanged() ? fillRange : removedRange; 0217 QCOMPARE(mByteArrayModel->byte(insertedRange.nextBeforeStart()), BlankChar); 0218 QCOMPARE(copy.compare(*mByteArrayModel, insertedRange, insertedRange.start() - behindEndSize), 0); 0219 QVERIFY(mByteArrayModel->isModified()); 0220 QCOMPARE(mByteArrayModel->size(), insertedRange.nextBehindEnd()); 0221 checkContentsReplaced(removedRange, insertedRange.width()); 0222 0223 // fill() at mid 0224 mByteArrayModel->setModified(false); 0225 mByteArrayModel->fill(BlankChar); 0226 fillRange.moveToStart(size / 2); 0227 clearSignalSpys(); 0228 0229 mByteArrayModel->fill(PaintChar, fillRange); 0230 QCOMPARE(mByteArrayModel->byte(fillRange.nextBeforeStart()), BlankChar); 0231 QCOMPARE(copy.compare(*mByteArrayModel, fillRange, fillRange.start()), 0); 0232 QCOMPARE(mByteArrayModel->byte(fillRange.nextBehindEnd()), BlankChar); 0233 QVERIFY(mByteArrayModel->isModified()); 0234 checkContentsReplaced(fillRange, fillRange.width()); 0235 } 0236 0237 void AbstractByteArrayModelIfTest::testSetGet() 0238 { 0239 // can we alter the buffer at all? 0240 if (mByteArrayModel->isReadOnly()) { 0241 // skip 0242 return; 0243 } 0244 0245 // prepare buffer 0246 Size size = mByteArrayModel->size(); 0247 mByteArrayModel->fill(BlankChar); 0248 0249 // test 0250 for (Address i = 0; i < size; ++i) { 0251 clearSignalSpys(); 0252 0253 mByteArrayModel->setModified(false); 0254 0255 mByteArrayModel->setByte(i, PaintChar); 0256 0257 if (i > 0) { 0258 QCOMPARE(mByteArrayModel->byte(i - 1), BlankChar); 0259 } 0260 QCOMPARE(mByteArrayModel->byte(i), PaintChar); 0261 if (i < size - 1) { 0262 QCOMPARE(mByteArrayModel->byte(i + 1), BlankChar); 0263 } 0264 checkContentsReplaced(i, 1, 1); 0265 0266 // clean up 0267 mByteArrayModel->setByte(i, BlankChar); 0268 QCOMPARE(mByteArrayModel->byte(i), BlankChar); 0269 QVERIFY(mByteArrayModel->isModified()); 0270 } 0271 } 0272 0273 // as some buffers might be restricted in growing 0274 // we test for the success of some operations 0275 void AbstractByteArrayModelIfTest::testRemove() 0276 { 0277 // can we alter the buffer at all? 0278 if (mByteArrayModel->isReadOnly()) { 0279 // skip 0280 return; 0281 } 0282 0283 textureByteArrayModel(mByteArrayModel); 0284 constexpr Size removeSize = 10; 0285 // create copy 0286 Size size = mByteArrayModel->size(); 0287 FixedSizeByteArrayModel copy(size); 0288 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0289 0290 // remove() at end 0291 mByteArrayModel->setModified(false); 0292 AddressRange removeRange(size - removeSize, size - 1); 0293 clearSignalSpys(); 0294 0295 Size removed = mByteArrayModel->remove(removeRange); 0296 removeRange.setEndByWidth(removed); 0297 0298 QCOMPARE(copy.compare(*mByteArrayModel, 0, removeRange.nextBeforeStart(), 0), 0); 0299 QCOMPARE(mByteArrayModel->isModified(), removed > 0); 0300 checkContentsReplaced(removeRange, 0); 0301 0302 // remove() at mid 0303 mByteArrayModel->setModified(false); 0304 size = mByteArrayModel->size(); 0305 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0306 removeRange.setByWidth(size / 2, removeSize); 0307 clearSignalSpys(); 0308 0309 removed = mByteArrayModel->remove(removeRange); 0310 removeRange.setEndByWidth(removed); 0311 0312 QCOMPARE(copy.compare(*mByteArrayModel, 0, removeRange.nextBeforeStart(), 0), 0); 0313 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(removeRange.start(), size - removed - 1), removeRange.nextBehindEnd()), 0); 0314 QCOMPARE(mByteArrayModel->isModified(), removed > 0); 0315 checkContentsReplaced(removeRange, 0); 0316 0317 // remove() at start 0318 mByteArrayModel->setModified(false); 0319 size = mByteArrayModel->size(); 0320 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0321 removeRange.setByWidth(0, removeSize); 0322 clearSignalSpys(); 0323 0324 removed = mByteArrayModel->remove(removeRange); 0325 removeRange.setEndByWidth(removed); 0326 0327 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(removeRange.start(), size - removed - 1), removeRange.nextBehindEnd()), 0); 0328 QCOMPARE(mByteArrayModel->isModified(), removed > 0); 0329 checkContentsReplaced(removeRange, 0); 0330 } 0331 0332 static constexpr Size insertSize = 10; 0333 0334 struct KTestData 0335 { 0336 FixedSizeByteArrayModel copy; 0337 FixedSizeByteArrayModel insertData; 0338 0339 KTestData(Size copySize, Size insertSize) : copy(copySize) 0340 , insertData(insertSize) {} 0341 const Byte* insertionData() { return insertData.rawData(); } 0342 }; 0343 0344 KTestData* AbstractByteArrayModelIfTest::prepareTestInsert() 0345 { 0346 Size size = mByteArrayModel->size(); 0347 0348 auto* testData = new KTestData(size + 3 * insertSize, insertSize); 0349 0350 // prepare insertData 0351 textureByteArrayModel(&testData->insertData, 10, 99); 0352 0353 textureByteArrayModel(mByteArrayModel, 100, 255); 0354 mByteArrayModel->copyTo(testData->copy.rawData(), 0, size); 0355 mByteArrayModel->setModified(false); 0356 return testData; 0357 } 0358 0359 void AbstractByteArrayModelIfTest::testInsertAtBegin() 0360 { 0361 // can we alter the buffer at all? 0362 if (mByteArrayModel->isReadOnly()) { 0363 // skip 0364 return; 0365 } 0366 0367 // prepare 0368 KTestData* data = prepareTestInsert(); 0369 Size size = mByteArrayModel->size(); 0370 AddressRange insertRange(0, -1); 0371 clearSignalSpys(); 0372 0373 Size inserted = mByteArrayModel->insert(insertRange.start(), data->insertData.rawData(), insertSize); 0374 insertRange.setEndByWidth(inserted); 0375 0376 QCOMPARE(data->insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0377 QCOMPARE(data->copy.compare(*mByteArrayModel, insertRange.nextBehindEnd(), size - insertRange.end() - 1, insertRange.start()), 0); 0378 QCOMPARE(mByteArrayModel->isModified(), inserted > 0); 0379 checkContentsReplaced(insertRange.start(), 0, inserted); 0380 0381 delete data; 0382 } 0383 0384 void AbstractByteArrayModelIfTest::testInsertAtMid() 0385 { 0386 // can we alter the buffer at all? 0387 if (mByteArrayModel->isReadOnly()) { 0388 // skip 0389 return; 0390 } 0391 0392 // prepare 0393 KTestData* data = prepareTestInsert(); 0394 Size size = mByteArrayModel->size(); 0395 AddressRange insertRange(size / 2, -1); 0396 clearSignalSpys(); 0397 0398 Size inserted = mByteArrayModel->insert(insertRange.start(), data->insertData.rawData(), insertSize); 0399 insertRange.setEndByWidth(inserted); 0400 0401 QCOMPARE(data->copy.compare(*mByteArrayModel, 0, insertRange.start(), 0), 0); 0402 QCOMPARE(data->insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0403 QCOMPARE(data->copy.compare(*mByteArrayModel, insertRange.nextBehindEnd(), size - insertRange.end() - 1, insertRange.start()), 0); 0404 QCOMPARE(mByteArrayModel->isModified(), inserted > 0); 0405 if (inserted > 0) { 0406 checkContentsReplaced(insertRange.start(), 0, inserted); 0407 } 0408 0409 delete data; 0410 } 0411 0412 void AbstractByteArrayModelIfTest::testInsertAtEnd() 0413 { 0414 // can we alter the buffer at all? 0415 if (mByteArrayModel->isReadOnly()) { 0416 // skip 0417 return; 0418 } 0419 0420 // prepare 0421 KTestData* data = prepareTestInsert(); 0422 Size size = mByteArrayModel->size(); 0423 AddressRange insertRange(size, -1); 0424 clearSignalSpys(); 0425 0426 Size inserted = mByteArrayModel->insert(insertRange.start(), data->insertData.rawData(), insertSize); 0427 insertRange.setEndByWidth(inserted); 0428 0429 // list( mByteArrayModel, "mByteArrayModel" ); 0430 // list( ©, "copy" ); 0431 // kdDebug() << QString("(%1-%2").arg(insertRange.start()).arg(insertRange.end()) << endl; 0432 QCOMPARE(data->copy.compare(*mByteArrayModel, 0, insertRange.start(), 0), 0); 0433 if (insertRange.isValid()) { 0434 QCOMPARE(data->insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0435 } 0436 QCOMPARE(mByteArrayModel->isModified(), inserted > 0); 0437 if (inserted > 0) { 0438 checkContentsReplaced(insertRange.start(), 0, inserted); 0439 } 0440 0441 delete data; 0442 } 0443 0444 // how the test works: 0445 // fills the buffer with random data, puts special data at the begin 0446 // copies data 0447 // moves the data to the mid, then the start. 0448 // tests for correct data, modified flag and size 0449 void AbstractByteArrayModelIfTest::testSwap() 0450 { 0451 // can we alter the buffer at all? 0452 if (mByteArrayModel->isReadOnly()) { 0453 // skip 0454 return; 0455 } 0456 0457 // prepare copy 0458 constexpr Size moveSize = 10; 0459 Size size = mByteArrayModel->size(); 0460 const AddressRange origin = AddressRange::fromWidth(size - moveSize, moveSize); 0461 FixedSizeByteArrayModel copy(size); 0462 0463 // prepare mByteArrayModel 0464 textureByteArrayModel(mByteArrayModel, 100, 255, 0, origin.nextBeforeStart()); 0465 textureByteArrayModel(mByteArrayModel, 10, 99, origin); 0466 AddressRange Source = origin; 0467 mByteArrayModel->setModified(false); 0468 0469 // create copy 0470 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0471 0472 // Action: move to middle (to left) 0473 Address destOffset = size / 2; 0474 AddressRange targetRange = AddressRange::fromWidth(destOffset, Source.width()); 0475 clearSignalSpys(); 0476 0477 bool success = mByteArrayModel->swap(destOffset, Source); 0478 0479 QVERIFY(success); 0480 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, targetRange.nextBeforeStart()), 0), 0); 0481 QCOMPARE(copy.compare(*mByteArrayModel, targetRange, origin.start()), 0); 0482 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(targetRange.nextBehindEnd(), size - 1), targetRange.start()), 0); 0483 QCOMPARE(mByteArrayModel->isModified(), success); 0484 QCOMPARE(mByteArrayModel->size(), size); 0485 checkContentsSwapped(destOffset, Source); 0486 0487 // clean 0488 mByteArrayModel->setModified(false); 0489 Source = targetRange; 0490 0491 // Action: move one in middle (to left) 0492 --destOffset; 0493 targetRange.moveToStart(destOffset); 0494 clearSignalSpys(); 0495 0496 success = mByteArrayModel->swap(destOffset, Source); 0497 0498 QVERIFY(success); 0499 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, targetRange.nextBeforeStart()), 0), 0); 0500 QCOMPARE(copy.compare(*mByteArrayModel, targetRange, origin.start()), 0); 0501 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(targetRange.nextBehindEnd(), size - 1), targetRange.start()), 0); 0502 QCOMPARE(mByteArrayModel->isModified(), success); 0503 QCOMPARE(mByteArrayModel->size(), size); 0504 checkContentsSwapped(destOffset, Source); 0505 0506 // clean 0507 mByteArrayModel->setModified(false); 0508 Source = targetRange; 0509 0510 // Action: move to start (to left) 0511 destOffset = 0; 0512 targetRange.moveToStart(destOffset); 0513 clearSignalSpys(); 0514 0515 success = mByteArrayModel->swap(destOffset, Source); 0516 0517 QVERIFY(success); 0518 QCOMPARE(copy.compare(*mByteArrayModel, targetRange, origin.start()), 0); 0519 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(targetRange.nextBehindEnd(), size - 1), targetRange.start()), 0); 0520 QCOMPARE(mByteArrayModel->isModified(), success); 0521 QCOMPARE(mByteArrayModel->size(), size); 0522 checkContentsSwapped(destOffset, Source); 0523 0524 #if 0 0525 // clean 0526 mByteArrayModel->setModified(false); 0527 Source = targetRange; 0528 0529 // Action: move to begin again (to left) 0530 destOffset = 0; 0531 targetRange = origin; 0532 clearSignalSpys(); 0533 0534 NewPos = mByteArrayModel->move(destOffset, Source); 0535 0536 QCOMPARE(NewPos, targetRange.start()); 0537 QCOMPARE(copy.compare(*mByteArrayModel, targetRange, origin.start()), 0); 0538 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(targetRange.nextBehindEnd(), size - 1), origin.nextBehindEnd()), 0); 0539 QCOMPARE(mByteArrayModel->isModified(), NewPos != Source.start()); 0540 QCOMPARE(mByteArrayModel->size(), size); 0541 checkContentsSwapped(destOffset, Source); 0542 #endif 0543 } 0544 0545 void AbstractByteArrayModelIfTest::testReplaceEqual() 0546 { 0547 // can we alter the buffer at all? 0548 if (mByteArrayModel->isReadOnly()) { 0549 // skip 0550 return; 0551 } 0552 0553 // create insertData 0554 constexpr Size removeSize = 10; 0555 constexpr Size insertSize = removeSize; 0556 FixedSizeByteArrayModel insertData(insertSize); 0557 textureByteArrayModel(&insertData, 10, 99); 0558 0559 // prepare mByteArrayModel 0560 Size size = mByteArrayModel->size(); 0561 textureByteArrayModel(mByteArrayModel, 100, 255); 0562 mByteArrayModel->setModified(false); 0563 0564 // create copy 0565 FixedSizeByteArrayModel copy(size); 0566 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0567 0568 // Action: move to begin again (to left) 0569 AddressRange targetRange = AddressRange::fromWidth(0, removeSize); 0570 clearSignalSpys(); 0571 0572 Size inserted = mByteArrayModel->replace(targetRange, insertData.rawData(), insertSize); 0573 0574 QCOMPARE(inserted, insertSize); 0575 QCOMPARE(insertData.compare(*mByteArrayModel, targetRange, 0), 0); 0576 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(targetRange.nextBehindEnd(), size - 1), targetRange.nextBehindEnd()), 0); 0577 QCOMPARE(mByteArrayModel->isModified(), true); 0578 QCOMPARE(mByteArrayModel->size(), size); 0579 checkContentsReplaced(targetRange, inserted); 0580 0581 // clean 0582 textureByteArrayModel(mByteArrayModel, 100, 255); 0583 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0584 mByteArrayModel->setModified(false); 0585 0586 // Action: replace at middle 0587 targetRange.moveToStart(size / 2); 0588 clearSignalSpys(); 0589 0590 inserted = mByteArrayModel->replace(targetRange, insertData.rawData(), insertSize); 0591 0592 QCOMPARE(inserted, insertSize); 0593 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, targetRange.nextBeforeStart()), 0), 0); 0594 QCOMPARE(insertData.compare(*mByteArrayModel, targetRange, 0), 0); 0595 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(targetRange.nextBehindEnd(), size - 1), targetRange.nextBehindEnd()), 0); 0596 QVERIFY(mByteArrayModel->isModified()); 0597 QCOMPARE(mByteArrayModel->size(), size); 0598 checkContentsReplaced(targetRange, inserted); 0599 0600 // clean 0601 textureByteArrayModel(mByteArrayModel, 100, 255); 0602 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0603 mByteArrayModel->setModified(false); 0604 0605 // Action: replace at end 0606 targetRange.moveToEnd(size - 1); 0607 clearSignalSpys(); 0608 0609 inserted = mByteArrayModel->replace(targetRange, insertData.rawData(), insertSize); 0610 0611 QCOMPARE(inserted, insertSize); 0612 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, targetRange.nextBeforeStart()), 0), 0); 0613 QCOMPARE(insertData.compare(*mByteArrayModel, targetRange, 0), 0); 0614 QVERIFY(mByteArrayModel->isModified()); 0615 QCOMPARE(mByteArrayModel->size(), size); 0616 checkContentsReplaced(targetRange, inserted); 0617 } 0618 0619 void AbstractByteArrayModelIfTest::testReplaceLess() 0620 { 0621 // can we alter the buffer at all? 0622 if (mByteArrayModel->isReadOnly()) { 0623 // skip 0624 return; 0625 } 0626 0627 // create insertData 0628 constexpr Size removeSize = 10; 0629 constexpr Size diff = 4; 0630 constexpr Size insertSize = removeSize - diff; 0631 FixedSizeByteArrayModel insertData(insertSize); 0632 textureByteArrayModel(&insertData, 10, 99); 0633 0634 // prepare mByteArrayModel 0635 Size size = mByteArrayModel->size(); 0636 textureByteArrayModel(mByteArrayModel, 100, 255); 0637 mByteArrayModel->setModified(false); 0638 0639 // create copy 0640 FixedSizeByteArrayModel copy(size); 0641 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0642 0643 // Action: replace at begin 0644 AddressRange removeRange = AddressRange::fromWidth(0, removeSize); 0645 AddressRange insertRange = AddressRange::fromWidth(0, insertSize); 0646 clearSignalSpys(); 0647 0648 Size inserted = mByteArrayModel->replace(removeRange, insertData.rawData(), insertSize); 0649 0650 QCOMPARE(inserted, insertSize); 0651 QCOMPARE(insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0652 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(insertRange.nextBehindEnd(), size - 1 - diff), removeRange.nextBehindEnd()), 0); 0653 QVERIFY(mByteArrayModel->isModified()); 0654 checkContentsReplaced(removeRange, inserted); 0655 0656 // clean 0657 size = mByteArrayModel->size(); 0658 textureByteArrayModel(mByteArrayModel, 100, 255); 0659 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0660 mByteArrayModel->setModified(false); 0661 0662 // Action: replace at middle 0663 removeRange.moveToStart(size / 2); 0664 insertRange.moveToStart(removeRange.start()); 0665 clearSignalSpys(); 0666 0667 inserted = mByteArrayModel->replace(removeRange, insertData.rawData(), insertSize); 0668 0669 QCOMPARE(inserted, insertSize); 0670 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, insertRange.nextBeforeStart()), 0), 0); 0671 QCOMPARE(insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0672 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(insertRange.nextBehindEnd(), size - 1 - diff), removeRange.nextBehindEnd()), 0); 0673 QVERIFY(mByteArrayModel->isModified()); 0674 checkContentsReplaced(removeRange, inserted); 0675 0676 // clean 0677 size = mByteArrayModel->size(); 0678 textureByteArrayModel(mByteArrayModel, 100, 255); 0679 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0680 mByteArrayModel->setModified(false); 0681 0682 // Action: replace at end 0683 removeRange.moveToEnd(size - 1); 0684 insertRange.moveToStart(removeRange.start()); 0685 clearSignalSpys(); 0686 0687 inserted = mByteArrayModel->replace(removeRange, insertData.rawData(), insertSize); 0688 0689 QCOMPARE(inserted, insertSize); 0690 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, insertRange.nextBeforeStart()), 0), 0); 0691 QCOMPARE(insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0692 QVERIFY(mByteArrayModel->isModified()); 0693 checkContentsReplaced(removeRange, inserted); 0694 } 0695 0696 void AbstractByteArrayModelIfTest::testReplaceMore() 0697 { 0698 // can we alter the buffer at all? 0699 if (mByteArrayModel->isReadOnly()) { 0700 // skip 0701 return; 0702 } 0703 0704 // create insertData 0705 constexpr Size removeSize = 10; 0706 constexpr Size diff = 4; 0707 constexpr Size insertSize = removeSize + diff; 0708 FixedSizeByteArrayModel insertData(insertSize); 0709 textureByteArrayModel(&insertData, 10, 99); 0710 0711 // prepare mByteArrayModel 0712 Size size = mByteArrayModel->size(); 0713 textureByteArrayModel(mByteArrayModel, 100, 255); 0714 mByteArrayModel->setModified(false); 0715 0716 // create copy 0717 FixedSizeByteArrayModel copy(size + 2 * insertSize); 0718 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0719 0720 // Action: replace at begin 0721 AddressRange removeRange = AddressRange::fromWidth(0, removeSize); 0722 AddressRange insertRange = AddressRange::fromWidth(0, insertSize); 0723 clearSignalSpys(); 0724 0725 Size inserted = mByteArrayModel->replace(removeRange, insertData.rawData(), insertSize); 0726 0727 QCOMPARE(inserted, insertSize); 0728 QCOMPARE(insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0729 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(insertRange.nextBehindEnd(), size - 1), removeRange.nextBehindEnd()), 0); 0730 QVERIFY(mByteArrayModel->isModified()); 0731 checkContentsReplaced(removeRange, inserted); 0732 0733 // clean 0734 size = mByteArrayModel->size(); 0735 textureByteArrayModel(mByteArrayModel, 100, 255); 0736 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0737 mByteArrayModel->setModified(false); 0738 // Action: replace at middle 0739 removeRange.moveToStart(size / 2); 0740 insertRange.moveToStart(removeRange.start()); 0741 clearSignalSpys(); 0742 0743 inserted = mByteArrayModel->replace(removeRange, insertData.rawData(), insertSize); 0744 0745 QCOMPARE(inserted, insertSize); 0746 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, insertRange.nextBeforeStart()), 0), 0); 0747 QCOMPARE(insertData.compare(*mByteArrayModel, insertRange, 0), 0); 0748 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(insertRange.nextBehindEnd(), size - 1), removeRange.nextBehindEnd()), 0); 0749 QVERIFY(mByteArrayModel->isModified()); 0750 checkContentsReplaced(removeRange, inserted); 0751 0752 // clean 0753 size = mByteArrayModel->size(); 0754 textureByteArrayModel(mByteArrayModel, 100, 255); 0755 mByteArrayModel->copyTo(copy.rawData(), 0, size); 0756 mByteArrayModel->setModified(false); 0757 0758 // Action: replace at end 0759 removeRange.moveToEnd(size - 1); 0760 insertRange.moveToStart(removeRange.start()); 0761 clearSignalSpys(); 0762 0763 inserted = mByteArrayModel->replace(removeRange, insertData.rawData(), insertSize); 0764 0765 QCOMPARE(removeSize <= inserted && inserted <= insertSize, true); 0766 QCOMPARE(copy.compare(*mByteArrayModel, AddressRange(0, insertRange.nextBeforeStart()), 0), 0); 0767 0768 QCOMPARE(insertData.compare(*mByteArrayModel, AddressRange(insertRange.start(), mByteArrayModel->size() - 1), 0), 0); 0769 QVERIFY(mByteArrayModel->isModified()); 0770 checkContentsReplaced(removeRange, inserted); 0771 } 0772 0773 } 0774 0775 #include "moc_abstractbytearraymodeliftest.cpp"