1 /**
2  * UGENE - Integrated Bioinformatics Tools.
3  * Copyright (C) 2008-2021 UniPro <ugene@unipro.ru>
4  * http://ugene.net
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19  * MA 02110-1301, USA.
20  */
21 
22 #include "SequenceDbiSQLiteSpecificUnitTests.h"
23 
24 #include <U2Core/DNAAlphabet.h>
25 #include <U2Core/U2Mod.h>
26 #include <U2Core/U2OpStatusUtils.h>
27 #include <U2Core/U2SequenceDbi.h>
28 #include <U2Core/U2SequenceUtils.h>
29 
30 #include <U2Formats/SQLiteDbi.h>
31 #include <U2Formats/SQLiteObjectDbi.h>
32 
33 namespace U2 {
34 
35 TestDbiProvider SequenceSQLiteSpecificTestData::dbiProvider = TestDbiProvider();
36 const QString &SequenceSQLiteSpecificTestData::SQLITE_SEQUENCE_DB_URL("sqlite-sequence-dbi.ugenedb");
37 SQLiteDbi *SequenceSQLiteSpecificTestData::sqliteDbi = nullptr;
38 
39 const QString SequenceSQLiteSpecificTestData::TEST_SEQUENCE_NAME = "Test sequence";
40 
init()41 void SequenceSQLiteSpecificTestData::init() {
42     SAFE_POINT(nullptr == sqliteDbi, "sqliteDbi has already been initialized!", );
43 
44     // Get URL
45     bool ok = dbiProvider.init(SQLITE_SEQUENCE_DB_URL, false);
46     SAFE_POINT(ok, "Dbi provider failed to initialize!", );
47 
48     U2Dbi *dbi = dbiProvider.getDbi();
49     QString url = dbi->getDbiRef().dbiId;
50     dbiProvider.close();
51 
52     // Init DBI
53     sqliteDbi = new SQLiteDbi();
54     QHash<QString, QString> initProperties;
55     initProperties[U2DbiOptions::U2_DBI_OPTION_URL] = url;
56     U2OpStatusImpl os;
57     sqliteDbi->init(initProperties, QVariantMap(), os);
58     SAFE_POINT_OP(os, );
59 
60     // Get sequences IDs
61     QList<U2DataId> ids = sqliteDbi->getObjectDbi()->getObjects(U2Type::Sequence, 0, U2DbiOptions::U2_DBI_NO_LIMIT, os);
62     SAFE_POINT_OP(os, );
63 }
64 
shutdown()65 void SequenceSQLiteSpecificTestData::shutdown() {
66     if (nullptr != sqliteDbi) {
67         U2OpStatusImpl os;
68         sqliteDbi->shutdown(os);
69         SAFE_POINT_OP(os, );
70         delete sqliteDbi;
71         sqliteDbi = nullptr;
72     }
73 }
74 
getSQLiteDbi()75 SQLiteDbi *SequenceSQLiteSpecificTestData::getSQLiteDbi() {
76     if (nullptr == sqliteDbi) {
77         init();
78     }
79     return sqliteDbi;
80 }
81 
createTestSequence(bool enableModTracking,qint64 seqLength,U2OpStatus & os)82 U2DataId SequenceSQLiteSpecificTestData::createTestSequence(bool enableModTracking, qint64 seqLength, U2OpStatus &os) {
83     U2Sequence sequence;
84     sequence.alphabet = BaseDNAAlphabetIds::NUCL_DNA_DEFAULT();
85     sequence.visualName = TEST_SEQUENCE_NAME;
86     if (false == enableModTracking) {
87         sequence.trackModType = NoTrack;
88     } else {
89         sequence.trackModType = TrackOnUpdate;
90     }
91     sqliteDbi->getSequenceDbi()->createSequenceObject(sequence, "", os);
92     CHECK_OP(os, "");
93 
94     QByteArray seq;
95     seq.fill('A', seqLength);
96 
97     sqliteDbi->getSequenceDbi()->updateSequenceData(sequence.id, U2_REGION_MAX, seq, QVariantMap(), os);
98     CHECK_OP(os, "");
99 
100     return sequence.id;
101 }
102 
createTestSequence(bool enableModTracking,const QByteArray & seqData,U2OpStatus & os)103 U2DataId SequenceSQLiteSpecificTestData::createTestSequence(bool enableModTracking, const QByteArray &seqData, U2OpStatus &os) {
104     U2Sequence sequence;
105     sequence.alphabet = BaseDNAAlphabetIds::NUCL_DNA_DEFAULT();
106     sequence.visualName = "Test sequence";
107     if (false == enableModTracking) {
108         sequence.trackModType = NoTrack;
109     } else {
110         sequence.trackModType = TrackOnUpdate;
111     }
112     sqliteDbi->getSequenceDbi()->createSequenceObject(sequence, "", os);
113     CHECK_OP(os, "");
114 
115     sqliteDbi->getSequenceDbi()->updateSequenceData(sequence.id, U2_REGION_MAX, seqData, QVariantMap(), os);
116     CHECK_OP(os, "");
117 
118     return sequence.id;
119 }
120 
getModStepsNum(const U2DataId & objId,U2OpStatus & os)121 qint64 SequenceSQLiteSpecificTestData::getModStepsNum(const U2DataId &objId, U2OpStatus &os) {
122     SQLiteReadQuery qModSteps("SELECT COUNT(*) FROM SingleModStep WHERE object = ?1", sqliteDbi->getDbRef(), os);
123     qModSteps.bindDataId(1, objId);
124     return qModSteps.selectInt64();
125 }
126 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_noModTrack)127 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_noModTrack) {
128     U2OpStatusImpl os;
129     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
130 
131     U2Sequence sequence;
132     sequence.alphabet = BaseDNAAlphabetIds::NUCL_DNA_DEFAULT();
133     sequence.visualName = SequenceSQLiteSpecificTestData::TEST_SEQUENCE_NAME;
134     sequence.trackModType = NoTrack;
135     sqliteDbi->getSequenceDbi()->createSequenceObject(sequence, "", os);
136     CHECK_NO_ERROR(os);
137 
138     // Some base values
139     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(sequence.id, os);
140     CHECK_NO_ERROR(os);
141     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(sequence.id, os);
142     CHECK_NO_ERROR(os);
143     CHECK_EQUAL(sequence.trackModType, baseSeqModType, "sequence track mod type");
144     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(sequence.id, os);
145     CHECK_NO_ERROR(os);
146 
147     // Prepare test data
148     QByteArray data("AAAAAAA");
149     U2Region region = U2_REGION_MAX;
150     QVariantMap hints;
151 
152     // Call test function
153     sqliteDbi->getSequenceDbi()->updateSequenceData(sequence.id, region, data, hints, os);
154     CHECK_NO_ERROR(os);
155 
156     // Verify version
157     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(sequence.id, os);
158     CHECK_NO_ERROR(os);
159     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
160 
161     // Verify mod type
162     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(sequence.id, os);
163     CHECK_NO_ERROR(os);
164     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
165 
166     // Verify mod steps num
167     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(sequence.id, os);
168     CHECK_NO_ERROR(os);
169     CHECK_EQUAL(baseModStepsNum, finalModStepsNum, "mod steps num");
170 
171     // Verify sequence object
172     U2Sequence finalSeq = sqliteDbi->getSequenceDbi()->getSequenceObject(sequence.id, os);
173     CHECK_NO_ERROR(os);
174     CHECK_EQUAL(sequence.alphabet.id, finalSeq.alphabet.id, "sequence alphabet");
175     CHECK_EQUAL(sequence.visualName, finalSeq.visualName, "sequence name");
176 
177     // Verify sequence data
178     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(sequence.id, U2_REGION_MAX, os);
179     CHECK_NO_ERROR(os);
180     CHECK_EQUAL(data, QString(finalData), "sequence data");
181 }
182 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyHint)183 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyHint) {
184     U2OpStatusImpl os;
185     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
186 
187     qint64 seqLength = 0;
188     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
189     CHECK_NO_ERROR(os);
190 
191     // Some base values
192     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
193     CHECK_NO_ERROR(os);
194     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
195     CHECK_NO_ERROR(os);
196     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
197     CHECK_NO_ERROR(os);
198 
199     // Prepare test data
200     QByteArray data("AAAAAAA");
201     U2Region region = U2_REGION_MAX;
202     QVariantMap hints;
203     hints.insert(U2SequenceDbiHints::EMPTY_SEQUENCE, true);
204 
205     // Call test function
206     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
207     CHECK_NO_ERROR(os);
208 
209     // Verify version
210     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
211     CHECK_NO_ERROR(os);
212     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
213 
214     // Verify mod type
215     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
216     CHECK_NO_ERROR(os);
217     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
218 
219     // Verify mod steps num
220     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
221     CHECK_NO_ERROR(os);
222     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
223 
224     // Verify modSteps
225     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
226     CHECK_NO_ERROR(os);
227     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
228     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
229     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
230     CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"empty-sequence,true\"", QString(modStep.details), "modStep details");
231 
232     // Verify sequence data
233     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
234     CHECK_NO_ERROR(os);
235     CHECK_EQUAL(data, QString(finalData), "sequence data");
236 }
237 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyNoHint)238 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyNoHint) {
239     U2OpStatusImpl os;
240     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
241 
242     qint64 seqLength = 0;
243     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
244     CHECK_NO_ERROR(os);
245 
246     // Some base values
247     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
248     CHECK_NO_ERROR(os);
249     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
250     CHECK_NO_ERROR(os);
251     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
252     CHECK_NO_ERROR(os);
253 
254     // Prepare test data
255     QByteArray data("AAAAAAA");
256     U2Region region = U2_REGION_MAX;
257     QVariantMap hints;
258 
259     // Call test function
260     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
261     CHECK_NO_ERROR(os);
262 
263     // Verify version
264     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
265     CHECK_NO_ERROR(os);
266     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
267 
268     // Verify mod type
269     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
270     CHECK_NO_ERROR(os);
271     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
272 
273     // Verify mod steps num
274     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
275     CHECK_NO_ERROR(os);
276     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
277 
278     // Verify modSteps
279     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
280     CHECK_NO_ERROR(os);
281     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
282     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
283     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
284     CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"\"", QString(modStep.details), "modStep details");
285 
286     // Verify sequence data
287     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
288     CHECK_NO_ERROR(os);
289     CHECK_EQUAL(data, QString(finalData), "sequence data");
290 }
291 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_clear)292 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_clear) {
293     U2OpStatusImpl os;
294     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
295 
296     QByteArray baseData("AAAAAAA");
297     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
298     CHECK_NO_ERROR(os);
299 
300     // Some base values
301     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
302     CHECK_NO_ERROR(os);
303     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
304     CHECK_NO_ERROR(os);
305     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
306     CHECK_NO_ERROR(os);
307 
308     // Prepare test data
309     QByteArray data("");
310     U2Region region = U2_REGION_MAX;
311     QVariantMap hints;
312 
313     // Call test function
314     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
315     CHECK_NO_ERROR(os);
316 
317     // Verify version
318     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
319     CHECK_NO_ERROR(os);
320     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
321 
322     // Verify mod type
323     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
324     CHECK_NO_ERROR(os);
325     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
326 
327     // Verify mod steps num
328     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
329     CHECK_NO_ERROR(os);
330     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
331 
332     // Verify modSteps
333     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
334     CHECK_NO_ERROR(os);
335     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
336     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
337     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
338     CHECK_EQUAL("0\t0\tAAAAAAA\t\t\"\"", QString(modStep.details), "modStep details");
339 
340     // Verify sequence data
341     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
342     CHECK_NO_ERROR(os);
343     CHECK_EQUAL(data, QString(finalData), "sequence data");
344 }
345 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_begin)346 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_begin) {
347     U2OpStatusImpl os;
348     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
349 
350     QByteArray baseData("AAAAAAA");
351     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
352     CHECK_NO_ERROR(os);
353 
354     // Some base values
355     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
356     CHECK_NO_ERROR(os);
357     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
358     CHECK_NO_ERROR(os);
359     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
360     CHECK_NO_ERROR(os);
361 
362     // Prepare test data
363     QByteArray data("CC");
364     U2Region region = U2Region(0, 3);
365     QVariantMap hints;
366 
367     // Prepare expected data
368     QByteArray expectedData = "CCAAAA";
369 
370     // Call test function
371     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
372     CHECK_NO_ERROR(os);
373 
374     // Verify version
375     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
376     CHECK_NO_ERROR(os);
377     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
378 
379     // Verify mod type
380     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
381     CHECK_NO_ERROR(os);
382     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
383 
384     // Verify mod steps num
385     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
386     CHECK_NO_ERROR(os);
387     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
388 
389     // Verify modSteps
390     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
391     CHECK_NO_ERROR(os);
392     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
393     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
394     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
395     CHECK_EQUAL("0\t0\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
396 
397     // Verify sequence data
398     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
399     CHECK_NO_ERROR(os);
400     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
401 }
402 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle)403 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle) {
404     U2OpStatusImpl os;
405     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
406 
407     QByteArray baseData("AAAAAAA");
408     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
409     CHECK_NO_ERROR(os);
410 
411     // Some base values
412     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
413     CHECK_NO_ERROR(os);
414     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
415     CHECK_NO_ERROR(os);
416     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
417     CHECK_NO_ERROR(os);
418 
419     // Prepare test data
420     QByteArray data("CC");
421     U2Region region = U2Region(2, 3);
422     QVariantMap hints;
423 
424     // Prepare expected data
425     QByteArray expectedData = "AACCAA";
426 
427     // Call test function
428     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
429     CHECK_NO_ERROR(os);
430 
431     // Verify version
432     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
433     CHECK_NO_ERROR(os);
434     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
435 
436     // Verify mod type
437     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
438     CHECK_NO_ERROR(os);
439     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
440 
441     // Verify mod steps num
442     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
443     CHECK_NO_ERROR(os);
444     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
445 
446     // Verify modSteps
447     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
448     CHECK_NO_ERROR(os);
449     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
450     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
451     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
452     CHECK_EQUAL("0\t2\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
453 
454     // Verify sequence data
455     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
456     CHECK_NO_ERROR(os);
457     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
458 }
459 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_middleNoLength)460 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_middleNoLength) {
461     U2OpStatusImpl os;
462     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
463 
464     QByteArray baseData("AAAAAAA");
465     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
466     CHECK_NO_ERROR(os);
467 
468     // Some base values
469     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
470     CHECK_NO_ERROR(os);
471     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
472     CHECK_NO_ERROR(os);
473     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
474     CHECK_NO_ERROR(os);
475 
476     // Prepare test data
477     QByteArray data("CC");
478     U2Region region = U2Region(2, 2);
479     QVariantMap hints;
480     hints.insert(U2SequenceDbiHints::UPDATE_SEQUENCE_LENGTH, false);
481 
482     // Prepare expected data
483     QByteArray expectedData = "AACCAAA";
484 
485     // Call test function
486     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
487     CHECK_NO_ERROR(os);
488 
489     // Verify version
490     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
491     CHECK_NO_ERROR(os);
492     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
493 
494     // Verify mod type
495     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
496     CHECK_NO_ERROR(os);
497     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
498 
499     // Verify mod steps num
500     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
501     CHECK_NO_ERROR(os);
502     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
503 
504     // Verify modSteps
505     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
506     CHECK_NO_ERROR(os);
507     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
508     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
509     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
510     CHECK_EQUAL("0\t2\tAA\tCC\t\"update-length,false\"", QString(modStep.details), "modStep details");
511 
512     // Verify sequence data
513     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
514     CHECK_NO_ERROR(os);
515     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
516 }
517 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_end)518 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_end) {
519     U2OpStatusImpl os;
520     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
521 
522     QByteArray baseData("AAAAAAA");
523     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
524     CHECK_NO_ERROR(os);
525 
526     // Some base values
527     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
528     CHECK_NO_ERROR(os);
529     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
530     CHECK_NO_ERROR(os);
531     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
532     CHECK_NO_ERROR(os);
533 
534     // Prepare test data
535     QByteArray data("CC");
536     U2Region region = U2Region(4, 3);
537     QVariantMap hints;
538 
539     // Prepare expected data
540     QByteArray expectedData = "AAAACC";
541 
542     // Call test function
543     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
544     CHECK_NO_ERROR(os);
545 
546     // Verify version
547     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
548     CHECK_NO_ERROR(os);
549     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
550 
551     // Verify mod type
552     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
553     CHECK_NO_ERROR(os);
554     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
555 
556     // Verify mod steps num
557     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
558     CHECK_NO_ERROR(os);
559     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
560 
561     // Verify modSteps
562     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
563     CHECK_NO_ERROR(os);
564     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
565     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
566     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
567     CHECK_EQUAL("0\t4\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
568 
569     // Verify sequence data
570     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
571     CHECK_NO_ERROR(os);
572     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
573 }
574 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyHint_undo)575 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyHint_undo) {
576     U2OpStatusImpl os;
577     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
578 
579     qint64 seqLength = 0;
580     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
581     CHECK_NO_ERROR(os);
582 
583     // Some base values
584     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
585     CHECK_NO_ERROR(os);
586     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
587     CHECK_NO_ERROR(os);
588     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
589     CHECK_NO_ERROR(os);
590 
591     // Prepare test data
592     QByteArray data("AAAAAAA");
593     U2Region region = U2_REGION_MAX;
594     QVariantMap hints;
595     hints.insert(U2SequenceDbiHints::EMPTY_SEQUENCE, true);
596 
597     // Call test function, undo changes
598     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
599     CHECK_NO_ERROR(os);
600     sqliteDbi->getObjectDbi()->undo(seqId, os);
601     CHECK_NO_ERROR(os);
602 
603     // Verify version
604     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
605     CHECK_NO_ERROR(os);
606     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
607 
608     // Verify mod type
609     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
610     CHECK_NO_ERROR(os);
611     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
612 
613     // Verify mod steps num
614     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
615     CHECK_NO_ERROR(os);
616     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
617 
618     // Verify modSteps
619     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
620     CHECK_NO_ERROR(os);
621     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
622     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
623     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
624     CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"empty-sequence,true\"", QString(modStep.details), "modStep details");
625 
626     // Verify sequence data
627     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
628     CHECK_NO_ERROR(os);
629     CHECK_EQUAL("", QString(finalData), "sequence data");
630 }
631 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyNoHint_undo)632 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyNoHint_undo) {
633     U2OpStatusImpl os;
634     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
635 
636     qint64 seqLength = 0;
637     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
638     CHECK_NO_ERROR(os);
639 
640     // Some base values
641     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
642     CHECK_NO_ERROR(os);
643     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
644     CHECK_NO_ERROR(os);
645     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
646     CHECK_NO_ERROR(os);
647 
648     // Prepare test data
649     QByteArray data("AAAAAAA");
650     U2Region region = U2_REGION_MAX;
651     QVariantMap hints;
652 
653     // Call test function, undo changes
654     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
655     CHECK_NO_ERROR(os);
656     sqliteDbi->getObjectDbi()->undo(seqId, os);
657     CHECK_NO_ERROR(os);
658 
659     // Verify version
660     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
661     CHECK_NO_ERROR(os);
662     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
663 
664     // Verify mod type
665     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
666     CHECK_NO_ERROR(os);
667     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
668 
669     // Verify mod steps num
670     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
671     CHECK_NO_ERROR(os);
672     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
673 
674     // Verify modSteps
675     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
676     CHECK_NO_ERROR(os);
677     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
678     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
679     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
680     CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"\"", QString(modStep.details), "modStep details");
681 
682     // Verify sequence data
683     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
684     CHECK_NO_ERROR(os);
685     CHECK_EQUAL("", QString(finalData), "sequence data");
686 }
687 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_clear_undo)688 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_clear_undo) {
689     U2OpStatusImpl os;
690     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
691 
692     QByteArray baseData("AAAAAAA");
693     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
694     CHECK_NO_ERROR(os);
695 
696     // Some base values
697     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
698     CHECK_NO_ERROR(os);
699     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
700     CHECK_NO_ERROR(os);
701     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
702     CHECK_NO_ERROR(os);
703 
704     // Prepare test data
705     QByteArray data("");
706     U2Region region = U2_REGION_MAX;
707     QVariantMap hints;
708 
709     // Call test function, undo changes
710     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
711     CHECK_NO_ERROR(os);
712     sqliteDbi->getObjectDbi()->undo(seqId, os);
713     CHECK_NO_ERROR(os);
714 
715     // Verify version
716     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
717     CHECK_NO_ERROR(os);
718     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
719 
720     // Verify mod type
721     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
722     CHECK_NO_ERROR(os);
723     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
724 
725     // Verify mod steps num
726     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
727     CHECK_NO_ERROR(os);
728     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
729 
730     // Verify modSteps
731     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
732     CHECK_NO_ERROR(os);
733     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
734     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
735     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
736     CHECK_EQUAL("0\t0\tAAAAAAA\t\t\"\"", QString(modStep.details), "modStep details");
737 
738     // Verify sequence data
739     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
740     CHECK_NO_ERROR(os);
741     CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
742 }
743 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_begin_undo)744 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_begin_undo) {
745     U2OpStatusImpl os;
746     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
747 
748     QByteArray baseData("AAAAAAA");
749     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
750     CHECK_NO_ERROR(os);
751 
752     // Some base values
753     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
754     CHECK_NO_ERROR(os);
755     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
756     CHECK_NO_ERROR(os);
757     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
758     CHECK_NO_ERROR(os);
759 
760     // Prepare test data
761     QByteArray data("CC");
762     U2Region region = U2Region(0, 3);
763     QVariantMap hints;
764 
765     // Call test function, undo changes
766     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
767     CHECK_NO_ERROR(os);
768     sqliteDbi->getObjectDbi()->undo(seqId, os);
769     CHECK_NO_ERROR(os);
770 
771     // Verify version
772     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
773     CHECK_NO_ERROR(os);
774     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
775 
776     // Verify mod type
777     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
778     CHECK_NO_ERROR(os);
779     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
780 
781     // Verify mod steps num
782     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
783     CHECK_NO_ERROR(os);
784     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
785 
786     // Verify modSteps
787     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
788     CHECK_NO_ERROR(os);
789     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
790     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
791     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
792     CHECK_EQUAL("0\t0\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
793 
794     // Verify sequence data
795     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
796     CHECK_NO_ERROR(os);
797     CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
798 }
799 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_undo)800 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_undo) {
801     U2OpStatusImpl os;
802     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
803 
804     QByteArray baseData("AAAAAAA");
805     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
806     CHECK_NO_ERROR(os);
807 
808     // Some base values
809     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
810     CHECK_NO_ERROR(os);
811     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
812     CHECK_NO_ERROR(os);
813     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
814     CHECK_NO_ERROR(os);
815 
816     // Prepare test data
817     QByteArray data("CC");
818     U2Region region = U2Region(2, 3);
819     QVariantMap hints;
820 
821     // Call test function, undo changes
822     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
823     CHECK_NO_ERROR(os);
824     sqliteDbi->getObjectDbi()->undo(seqId, os);
825     CHECK_NO_ERROR(os);
826 
827     // Verify version
828     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
829     CHECK_NO_ERROR(os);
830     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
831 
832     // Verify mod type
833     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
834     CHECK_NO_ERROR(os);
835     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
836 
837     // Verify mod steps num
838     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
839     CHECK_NO_ERROR(os);
840     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
841 
842     // Verify modSteps
843     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
844     CHECK_NO_ERROR(os);
845     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
846     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
847     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
848     CHECK_EQUAL("0\t2\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
849 
850     // Verify sequence data
851     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
852     CHECK_NO_ERROR(os);
853     CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
854 }
855 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_middleNoLength_undo)856 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_middleNoLength_undo) {
857     U2OpStatusImpl os;
858     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
859 
860     QByteArray baseData("AAAAAAA");
861     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
862     CHECK_NO_ERROR(os);
863 
864     // Some base values
865     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
866     CHECK_NO_ERROR(os);
867     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
868     CHECK_NO_ERROR(os);
869     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
870     CHECK_NO_ERROR(os);
871 
872     // Prepare test data
873     QByteArray data("CC");
874     U2Region region = U2Region(2, 2);
875     QVariantMap hints;
876     hints.insert(U2SequenceDbiHints::UPDATE_SEQUENCE_LENGTH, false);
877 
878     // Call test function, undo changes
879     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
880     CHECK_NO_ERROR(os);
881     sqliteDbi->getObjectDbi()->undo(seqId, os);
882     CHECK_NO_ERROR(os);
883 
884     // Verify version
885     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
886     CHECK_NO_ERROR(os);
887     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
888 
889     // Verify mod type
890     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
891     CHECK_NO_ERROR(os);
892     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
893 
894     // Verify mod steps num
895     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
896     CHECK_NO_ERROR(os);
897     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
898 
899     // Verify modSteps
900     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
901     CHECK_NO_ERROR(os);
902     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
903     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
904     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
905     CHECK_EQUAL("0\t2\tAA\tCC\t\"update-length,false\"", QString(modStep.details), "modStep details");
906 
907     // Verify sequence data
908     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
909     CHECK_NO_ERROR(os);
910     CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
911 }
912 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_end_undo)913 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_end_undo) {
914     U2OpStatusImpl os;
915     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
916 
917     QByteArray baseData("AAAAAAA");
918     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
919     CHECK_NO_ERROR(os);
920 
921     // Some base values
922     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
923     CHECK_NO_ERROR(os);
924     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
925     CHECK_NO_ERROR(os);
926     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
927     CHECK_NO_ERROR(os);
928 
929     // Prepare test data
930     QByteArray data("CC");
931     U2Region region = U2Region(4, 3);
932     QVariantMap hints;
933 
934     // Call test function, undo changes
935     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
936     CHECK_NO_ERROR(os);
937     sqliteDbi->getObjectDbi()->undo(seqId, os);
938     CHECK_NO_ERROR(os);
939 
940     // Verify version
941     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
942     CHECK_NO_ERROR(os);
943     CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
944 
945     // Verify mod type
946     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
947     CHECK_NO_ERROR(os);
948     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
949 
950     // Verify mod steps num
951     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
952     CHECK_NO_ERROR(os);
953     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
954 
955     // Verify modSteps
956     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
957     CHECK_NO_ERROR(os);
958     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
959     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
960     CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
961     CHECK_EQUAL("0\t4\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
962 
963     // Verify sequence data
964     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
965     CHECK_NO_ERROR(os);
966     CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
967 }
968 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyHint_redo)969 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyHint_redo) {
970     U2OpStatusImpl os;
971     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
972 
973     qint64 seqLength = 0;
974     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
975     CHECK_NO_ERROR(os);
976 
977     // Some base values
978     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
979     CHECK_NO_ERROR(os);
980     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
981     CHECK_NO_ERROR(os);
982     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
983     CHECK_NO_ERROR(os);
984 
985     // Prepare test data
986     QByteArray data("AAAAAAA");
987     U2Region region = U2_REGION_MAX;
988     QVariantMap hints;
989     hints.insert(U2SequenceDbiHints::EMPTY_SEQUENCE, true);
990 
991     // Call test function, undo and redo changes
992     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
993     CHECK_NO_ERROR(os);
994     sqliteDbi->getObjectDbi()->undo(seqId, os);
995     CHECK_NO_ERROR(os);
996     CHECK_NO_ERROR(os);
997     sqliteDbi->getObjectDbi()->redo(seqId, os);
998     CHECK_NO_ERROR(os);
999 
1000     // Verify version
1001     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1002     CHECK_NO_ERROR(os);
1003     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1004 
1005     // Verify mod type
1006     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1007     CHECK_NO_ERROR(os);
1008     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1009 
1010     // Verify mod steps num
1011     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1012     CHECK_NO_ERROR(os);
1013     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1014 
1015     // Verify modSteps
1016     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1017     CHECK_NO_ERROR(os);
1018     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1019     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1020     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1021     CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"empty-sequence,true\"", QString(modStep.details), "modStep details");
1022 
1023     // Verify sequence data
1024     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1025     CHECK_NO_ERROR(os);
1026     CHECK_EQUAL(data, QString(finalData), "sequence data");
1027 }
1028 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyNoHint_redo)1029 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyNoHint_redo) {
1030     U2OpStatusImpl os;
1031     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1032 
1033     qint64 seqLength = 0;
1034     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
1035     CHECK_NO_ERROR(os);
1036 
1037     // Some base values
1038     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1039     CHECK_NO_ERROR(os);
1040     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1041     CHECK_NO_ERROR(os);
1042     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1043     CHECK_NO_ERROR(os);
1044 
1045     // Prepare test data
1046     QByteArray data("AAAAAAA");
1047     U2Region region = U2_REGION_MAX;
1048     QVariantMap hints;
1049 
1050     // Call test function, undo and redo changes
1051     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1052     CHECK_NO_ERROR(os);
1053     sqliteDbi->getObjectDbi()->undo(seqId, os);
1054     CHECK_NO_ERROR(os);
1055     CHECK_NO_ERROR(os);
1056     sqliteDbi->getObjectDbi()->redo(seqId, os);
1057     CHECK_NO_ERROR(os);
1058 
1059     // Verify version
1060     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1061     CHECK_NO_ERROR(os);
1062     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1063 
1064     // Verify mod type
1065     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1066     CHECK_NO_ERROR(os);
1067     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1068 
1069     // Verify mod steps num
1070     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1071     CHECK_NO_ERROR(os);
1072     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1073 
1074     // Verify modSteps
1075     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1076     CHECK_NO_ERROR(os);
1077     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1078     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1079     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1080     CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"\"", QString(modStep.details), "modStep details");
1081 
1082     // Verify sequence data
1083     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1084     CHECK_NO_ERROR(os);
1085     CHECK_EQUAL(data, QString(finalData), "sequence data");
1086 }
1087 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_clear_redo)1088 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_clear_redo) {
1089     U2OpStatusImpl os;
1090     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1091 
1092     QByteArray baseData("AAAAAAA");
1093     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1094     CHECK_NO_ERROR(os);
1095 
1096     // Some base values
1097     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1098     CHECK_NO_ERROR(os);
1099     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1100     CHECK_NO_ERROR(os);
1101     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1102     CHECK_NO_ERROR(os);
1103 
1104     // Prepare test data
1105     QByteArray data("");
1106     U2Region region = U2_REGION_MAX;
1107     QVariantMap hints;
1108 
1109     // Call test function, undo and redo changes
1110     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1111     CHECK_NO_ERROR(os);
1112     sqliteDbi->getObjectDbi()->undo(seqId, os);
1113     CHECK_NO_ERROR(os);
1114     CHECK_NO_ERROR(os);
1115     sqliteDbi->getObjectDbi()->redo(seqId, os);
1116     CHECK_NO_ERROR(os);
1117 
1118     // Verify version
1119     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1120     CHECK_NO_ERROR(os);
1121     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1122 
1123     // Verify mod type
1124     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1125     CHECK_NO_ERROR(os);
1126     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1127 
1128     // Verify mod steps num
1129     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1130     CHECK_NO_ERROR(os);
1131     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1132 
1133     // Verify modSteps
1134     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1135     CHECK_NO_ERROR(os);
1136     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1137     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1138     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1139     CHECK_EQUAL("0\t0\tAAAAAAA\t\t\"\"", QString(modStep.details), "modStep details");
1140 
1141     // Verify sequence data
1142     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1143     CHECK_NO_ERROR(os);
1144     CHECK_EQUAL(data, QString(finalData), "sequence data");
1145 }
1146 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_begin_redo)1147 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_begin_redo) {
1148     U2OpStatusImpl os;
1149     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1150 
1151     QByteArray baseData("AAAAAAA");
1152     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1153     CHECK_NO_ERROR(os);
1154 
1155     // Some base values
1156     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1157     CHECK_NO_ERROR(os);
1158     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1159     CHECK_NO_ERROR(os);
1160     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1161     CHECK_NO_ERROR(os);
1162 
1163     // Prepare test data
1164     QByteArray data("CC");
1165     U2Region region = U2Region(0, 3);
1166     QVariantMap hints;
1167 
1168     // Prepare expected data
1169     QByteArray expectedData = "CCAAAA";
1170 
1171     // Call test function, undo and redo changes
1172     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1173     CHECK_NO_ERROR(os);
1174     sqliteDbi->getObjectDbi()->undo(seqId, os);
1175     CHECK_NO_ERROR(os);
1176     CHECK_NO_ERROR(os);
1177     sqliteDbi->getObjectDbi()->redo(seqId, os);
1178     CHECK_NO_ERROR(os);
1179 
1180     // Verify version
1181     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1182     CHECK_NO_ERROR(os);
1183     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1184 
1185     // Verify mod type
1186     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1187     CHECK_NO_ERROR(os);
1188     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1189 
1190     // Verify mod steps num
1191     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1192     CHECK_NO_ERROR(os);
1193     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1194 
1195     // Verify modSteps
1196     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1197     CHECK_NO_ERROR(os);
1198     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1199     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1200     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1201     CHECK_EQUAL("0\t0\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
1202 
1203     // Verify sequence data
1204     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1205     CHECK_NO_ERROR(os);
1206     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1207 }
1208 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_redo)1209 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_redo) {
1210     U2OpStatusImpl os;
1211     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1212 
1213     QByteArray baseData("AAAAAAA");
1214     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1215     CHECK_NO_ERROR(os);
1216 
1217     // Some base values
1218     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1219     CHECK_NO_ERROR(os);
1220     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1221     CHECK_NO_ERROR(os);
1222     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1223     CHECK_NO_ERROR(os);
1224 
1225     // Prepare test data
1226     QByteArray data("CC");
1227     U2Region region = U2Region(2, 3);
1228     QVariantMap hints;
1229 
1230     // Prepare expected data
1231     QByteArray expectedData = "AACCAA";
1232 
1233     // Call test function, undo and redo changes
1234     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1235     CHECK_NO_ERROR(os);
1236     sqliteDbi->getObjectDbi()->undo(seqId, os);
1237     CHECK_NO_ERROR(os);
1238     CHECK_NO_ERROR(os);
1239     sqliteDbi->getObjectDbi()->redo(seqId, os);
1240     CHECK_NO_ERROR(os);
1241 
1242     // Verify version
1243     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1244     CHECK_NO_ERROR(os);
1245     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1246 
1247     // Verify mod type
1248     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1249     CHECK_NO_ERROR(os);
1250     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1251 
1252     // Verify mod steps num
1253     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1254     CHECK_NO_ERROR(os);
1255     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1256 
1257     // Verify modSteps
1258     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1259     CHECK_NO_ERROR(os);
1260     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1261     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1262     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1263     CHECK_EQUAL("0\t2\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
1264 
1265     // Verify sequence data
1266     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1267     CHECK_NO_ERROR(os);
1268     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1269 }
1270 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_middleNoLength_redo)1271 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_middleNoLength_redo) {
1272     U2OpStatusImpl os;
1273     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1274 
1275     QByteArray baseData("AAAAAAA");
1276     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1277     CHECK_NO_ERROR(os);
1278 
1279     // Some base values
1280     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1281     CHECK_NO_ERROR(os);
1282     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1283     CHECK_NO_ERROR(os);
1284     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1285     CHECK_NO_ERROR(os);
1286 
1287     // Prepare test data
1288     QByteArray data("CC");
1289     U2Region region = U2Region(2, 2);
1290     QVariantMap hints;
1291     hints.insert(U2SequenceDbiHints::UPDATE_SEQUENCE_LENGTH, false);
1292 
1293     // Prepare expected data
1294     QByteArray expectedData = "AACCAAA";
1295 
1296     // Call test function, undo and redo changes
1297     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1298     CHECK_NO_ERROR(os);
1299     sqliteDbi->getObjectDbi()->undo(seqId, os);
1300     CHECK_NO_ERROR(os);
1301     CHECK_NO_ERROR(os);
1302     sqliteDbi->getObjectDbi()->redo(seqId, os);
1303     CHECK_NO_ERROR(os);
1304 
1305     // Verify version
1306     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1307     CHECK_NO_ERROR(os);
1308     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1309 
1310     // Verify mod type
1311     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1312     CHECK_NO_ERROR(os);
1313     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1314 
1315     // Verify mod steps num
1316     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1317     CHECK_NO_ERROR(os);
1318     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1319 
1320     // Verify modSteps
1321     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1322     CHECK_NO_ERROR(os);
1323     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1324     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1325     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1326     CHECK_EQUAL("0\t2\tAA\tCC\t\"update-length,false\"", QString(modStep.details), "modStep details");
1327 
1328     // Verify sequence data
1329     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1330     CHECK_NO_ERROR(os);
1331     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1332 }
1333 
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_end_redo)1334 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_end_redo) {
1335     U2OpStatusImpl os;
1336     SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1337 
1338     QByteArray baseData("AAAAAAA");
1339     U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1340     CHECK_NO_ERROR(os);
1341 
1342     // Some base values
1343     qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1344     CHECK_NO_ERROR(os);
1345     U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1346     CHECK_NO_ERROR(os);
1347     qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1348     CHECK_NO_ERROR(os);
1349 
1350     // Prepare test data
1351     QByteArray data("CC");
1352     U2Region region = U2Region(4, 3);
1353     QVariantMap hints;
1354 
1355     // Prepare expected data
1356     QByteArray expectedData = "AAAACC";
1357 
1358     // Call test function, undo and redo changes
1359     sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1360     CHECK_NO_ERROR(os);
1361     sqliteDbi->getObjectDbi()->undo(seqId, os);
1362     CHECK_NO_ERROR(os);
1363     CHECK_NO_ERROR(os);
1364     sqliteDbi->getObjectDbi()->redo(seqId, os);
1365     CHECK_NO_ERROR(os);
1366 
1367     // Verify version
1368     qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1369     CHECK_NO_ERROR(os);
1370     CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1371 
1372     // Verify mod type
1373     U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1374     CHECK_NO_ERROR(os);
1375     CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1376 
1377     // Verify mod steps num
1378     qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1379     CHECK_NO_ERROR(os);
1380     CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1381 
1382     // Verify modSteps
1383     U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1384     CHECK_NO_ERROR(os);
1385     CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1386     CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1387     CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1388     CHECK_EQUAL("0\t4\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
1389 
1390     // Verify sequence data
1391     QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1392     CHECK_NO_ERROR(os);
1393     CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1394 }
1395 
1396 }  // namespace U2
1397