1 // ==========================================================================
2 // SeqAn - The Library for Sequence Analysis
3 // ==========================================================================
4 // Copyright (c) 2006-2018, Knut Reinert, FU Berlin
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions are met:
9 //
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // * Redistributions in binary form must reproduce the above copyright
13 // notice, this list of conditions and the following disclaimer in the
14 // documentation and/or other materials provided with the distribution.
15 // * Neither the name of Knut Reinert or the FU Berlin nor the names of
16 // its contributors may be used to endorse or promote products derived
17 // from this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 // ARE DISCLAIMED. IN NO EVENT SHALL KNUT REINERT OR THE FU BERLIN BE LIABLE
23 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
29 // DAMAGE.
30 //
31 // ==========================================================================
32 // Author: Rene Rahn <rene.rahn@fu-berlin.de>
33 // ==========================================================================
34 // Test for the delta map.
35 // ==========================================================================
36
37 #ifndef TESTS_JOURNALED_STRING_TREE_TEST_DELTA_MAP_H_
38 #define TESTS_JOURNALED_STRING_TREE_TEST_DELTA_MAP_H_
39
40 #include <seqan/basic.h>
41 #include <seqan/sequence.h>
42 #include <seqan/journaled_string_tree.h>
43
44 using namespace seqan;
45
46 struct TestDeltaMapConfig
47 {
48 typedef unsigned TDeltaPos;
49 typedef Dna TSnpValue;
50 typedef DnaString TInsValue;
51 typedef unsigned TDelValue;
52 typedef Pair<unsigned, DnaString> TSVValue;
53 };
54
55 template <typename TCoverage, typename TSize>
56 inline void
_getCoverage(TCoverage & cov,TSize size,TSize remainder)57 _getCoverage(TCoverage & cov, TSize size, TSize remainder)
58 {
59 resize(cov, size);
60 for (unsigned i = 0; i < length(cov); ++i)
61 cov[i] = (!(i % remainder)) ? true : false;
62 }
63
64 template <typename TConfig, typename TSpec>
createMock(DeltaMap<TConfig,TSpec> & map)65 inline void createMock(DeltaMap<TConfig, TSpec> & map)
66 {
67 typedef DeltaMap<TConfig, TSpec> TDeltMap;
68 typedef typename Member<TDeltMap, DeltaMapEntriesMember>::Type TEntries;
69 typedef typename Member<TDeltMap, DeltaMapStoreMember>::Type TStore;
70 typedef typename DeltaValue<TStore, DeltaTypeSV>::Type TSV;
71 typedef typename Value<TEntries>::Type TEntry;
72 typedef typename DeltaCoverage<TEntry>::Type TCoverage;
73
74 TCoverage cov1;
75 _getCoverage(cov1, 10, 3);
76 TCoverage cov2;
77 _getCoverage(cov2, 10, 5);
78 TCoverage cov3;
79 _getCoverage(cov3, 10, 2);
80
81 insert(map, 5, 1, cov3, DeltaTypeDel());
82 insert(map, 1, TSV(2, "TGAT"), cov1, DeltaTypeSV());
83 insert(map, 4, "ACGT", cov3, DeltaTypeIns());
84 insert(map, 2, 'C', cov2, DeltaTypeSnp());
85 insert(map, 20, 2, cov2, DeltaTypeDel());
86 insert(map, 0, 'A', cov1, DeltaTypeSnp());
87 insert(map, 1, 3, cov2, DeltaTypeDel());
88 }
89
SEQAN_DEFINE_TEST(test_delta_map_insert)90 SEQAN_DEFINE_TEST(test_delta_map_insert)
91 {
92 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
93 typedef typename DeltaCoverage<TDeltaMap>::Type TCoverage;
94 typedef typename Member<TDeltaMap, DeltaMapEntriesMember>::Type TEntries;
95 typedef typename Value<TEntries>::Type TEntry;
96 typedef DeltaRecord<TEntry>::Type TRecord;
97
98 TDeltaMap deltaMap;
99 createMock(deltaMap);
100
101 TCoverage cov1;
102 _getCoverage(cov1, 10, 3);
103 TCoverage cov2;
104 _getCoverage(cov2, 10, 5);
105 TCoverage cov3;
106 _getCoverage(cov3, 10, 2);
107
108 insert(deltaMap, 2, deltaMap._deltaStore._snpData[0], cov2, DeltaTypeSnp());
109 insert(deltaMap, 1, deltaMap._deltaStore._svData[0], cov1, DeltaTypeSV());
110 insert(deltaMap, 1, deltaMap._deltaStore._delData[2], cov2, DeltaTypeDel());
111 insert(deltaMap, 3, 1, cov1, DeltaTypeDel());
112 insert(deltaMap, 3, 4, cov1, DeltaTypeDel());
113
114 SEQAN_ASSERT_EQ(deltaMap._entries[0], TEntry(0, TRecord(DELTA_TYPE_SNP, 1), cov1, DeltaEndType::IS_BOTH));
115 SEQAN_ASSERT_EQ(deltaMap._entries[1], TEntry(1, TRecord(DELTA_TYPE_DEL, 2), cov2, DeltaEndType::IS_LEFT));
116 SEQAN_ASSERT_EQ(deltaMap._entries[2], TEntry(1, TRecord(DELTA_TYPE_DEL, 3), cov2, DeltaEndType::IS_LEFT));
117 SEQAN_ASSERT_EQ(deltaMap._entries[3], TEntry(1, TRecord(DELTA_TYPE_SV, 0), cov1, DeltaEndType::IS_LEFT));
118 SEQAN_ASSERT_EQ(deltaMap._entries[4], TEntry(1, TRecord(DELTA_TYPE_SV, 1), cov1, DeltaEndType::IS_LEFT));
119 SEQAN_ASSERT_EQ(deltaMap._entries[5], TEntry(2, TRecord(DELTA_TYPE_SNP, 0), cov2, DeltaEndType::IS_BOTH));
120 SEQAN_ASSERT_EQ(deltaMap._entries[6], TEntry(2, TRecord(DELTA_TYPE_SNP, 2), cov2, DeltaEndType::IS_BOTH));
121 SEQAN_ASSERT_EQ(deltaMap._entries[7], TEntry(2, TRecord(DELTA_TYPE_SV, 0), cov1, DeltaEndType::IS_RIGHT));
122 SEQAN_ASSERT_EQ(deltaMap._entries[8], TEntry(2, TRecord(DELTA_TYPE_SV, 1), cov1, DeltaEndType::IS_RIGHT));
123 SEQAN_ASSERT_EQ(deltaMap._entries[9], TEntry(3, TRecord(DELTA_TYPE_DEL, 2), cov2, DeltaEndType::IS_RIGHT));
124 SEQAN_ASSERT_EQ(deltaMap._entries[10], TEntry(3, TRecord(DELTA_TYPE_DEL, 3), cov2, DeltaEndType::IS_RIGHT));
125 SEQAN_ASSERT_EQ(deltaMap._entries[11], TEntry(3, TRecord(DELTA_TYPE_DEL, 4), cov1, DeltaEndType::IS_BOTH));
126 SEQAN_ASSERT_EQ(deltaMap._entries[12], TEntry(3, TRecord(DELTA_TYPE_DEL, 5), cov1, DeltaEndType::IS_LEFT));
127 SEQAN_ASSERT_EQ(deltaMap._entries[13], TEntry(4, TRecord(DELTA_TYPE_INS, 0), cov3, DeltaEndType::IS_BOTH));
128 SEQAN_ASSERT_EQ(deltaMap._entries[14], TEntry(5, TRecord(DELTA_TYPE_DEL, 0), cov3, DeltaEndType::IS_BOTH));
129 SEQAN_ASSERT_EQ(deltaMap._entries[15], TEntry(6, TRecord(DELTA_TYPE_DEL, 5), cov1, DeltaEndType::IS_RIGHT));
130 SEQAN_ASSERT_EQ(deltaMap._entries[16], TEntry(20, TRecord(DELTA_TYPE_DEL, 1), cov2, DeltaEndType::IS_LEFT));
131 SEQAN_ASSERT_EQ(deltaMap._entries[17], TEntry(21, TRecord(DELTA_TYPE_DEL, 1), cov2, DeltaEndType::IS_RIGHT));
132 }
133
SEQAN_DEFINE_TEST(test_delta_map_erase)134 SEQAN_DEFINE_TEST(test_delta_map_erase)
135 {
136 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
137 typedef typename DeltaCoverage<TDeltaMap>::Type TCoverage;
138
139 TDeltaMap deltaMap;
140 createMock(deltaMap);
141
142 TCoverage cov2;
143 _getCoverage(cov2, 10, 5);
144 insert(deltaMap, 1, deltaMap._deltaStore._delData[2], cov2, DeltaTypeDel());
145
146 SEQAN_ASSERT_EQ(erase(deltaMap, 2, DeltaTypeSnp()), 1u);
147 SEQAN_ASSERT_EQ(erase(deltaMap, 5, DeltaTypeDel()), 1u);
148 SEQAN_ASSERT_EQ(erase(deltaMap, 1, DeltaTypeSV()), 2u);
149 SEQAN_ASSERT_EQ(erase(deltaMap, 0, DeltaTypeSnp()), 1u);
150 SEQAN_ASSERT_EQ(erase(deltaMap, 4, DeltaTypeIns()), 1u);
151 SEQAN_ASSERT_EQ(erase(deltaMap, 20, DeltaTypeDel()), 2u);
152 SEQAN_ASSERT_EQ(erase(deltaMap, 1, DeltaTypeDel()), 4u);
153 SEQAN_ASSERT_EQ(length(deltaMap._entries), 0u);
154 SEQAN_ASSERT_EQ(length(deltaMap._deltaStore._snpData), 0u);
155 SEQAN_ASSERT_EQ(length(deltaMap._deltaStore._delData), 0u);
156 SEQAN_ASSERT_EQ(length(deltaMap._deltaStore._insData), 0u);
157 SEQAN_ASSERT_EQ(length(deltaMap._deltaStore._svData), 0u);
158 SEQAN_ASSERT_EQ(erase(deltaMap, 1, DeltaTypeDel()), 0u);
159 }
160
SEQAN_DEFINE_TEST(test_delta_map_lower_bound)161 SEQAN_DEFINE_TEST(test_delta_map_lower_bound)
162 {
163
164 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
165 typedef typename DeltaCoverage<TDeltaMap>::Type TCoverage;
166 typedef typename Member<TDeltaMap, DeltaMapEntriesMember>::Type TEntries;
167 typedef typename Value<TEntries>::Type TEntry;
168 typedef DeltaRecord<TEntry>::Type TRecord;
169
170 TDeltaMap deltaMap;
171 createMock(deltaMap);
172
173 TCoverage cov1;
174 _getCoverage(cov1, 10, 3);
175 TCoverage cov2;
176 _getCoverage(cov2, 10, 5);
177 TCoverage cov3;
178 _getCoverage(cov3, 10, 2);
179
180 insert(deltaMap, 1, deltaMap._deltaStore._delData[2], cov1, DeltaTypeDel());
181 SEQAN_ASSERT_EQ(*lowerBound(deltaMap, 7, DeltaTypeSnp()), TEntry(20, TRecord(DELTA_TYPE_DEL, 1), cov2, DeltaEndType::IS_LEFT));
182 SEQAN_ASSERT(lowerBound(deltaMap, 22, DeltaTypeSnp()) == end(deltaMap, Standard()));
183 SEQAN_ASSERT_EQ(*lowerBound(deltaMap, 4, DeltaTypeIns()), TEntry(4, TRecord(DELTA_TYPE_INS, 0), cov3, DeltaEndType::IS_BOTH));
184 SEQAN_ASSERT_EQ(*lowerBound(deltaMap, 1, DeltaTypeDel()), TEntry(1, TRecord(DELTA_TYPE_DEL, 2), cov2, DeltaEndType::IS_LEFT));
185 }
186
SEQAN_DEFINE_TEST(test_delta_map_upper_bound)187 SEQAN_DEFINE_TEST(test_delta_map_upper_bound)
188 {
189 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
190 typedef typename DeltaCoverage<TDeltaMap>::Type TCoverage;
191 typedef typename Member<TDeltaMap, DeltaMapEntriesMember>::Type TEntries;
192 typedef typename Value<TEntries>::Type TEntry;
193 typedef DeltaRecord<TEntry>::Type TRecord;
194
195 TDeltaMap deltaMap;
196 createMock(deltaMap);
197
198 TCoverage cov1;
199 _getCoverage(cov1, 10, 3);
200 TCoverage cov2;
201 _getCoverage(cov2, 10, 5);
202 TCoverage cov3;
203 _getCoverage(cov3, 10, 2);
204
205 insert(deltaMap, 1, deltaMap._deltaStore._delData[2], cov1, DeltaTypeDel());
206 SEQAN_ASSERT_EQ(*upperBound(deltaMap, 7, DeltaTypeSnp()), TEntry(20, TRecord(DELTA_TYPE_DEL, 1), cov2, DeltaEndType::IS_LEFT));
207 SEQAN_ASSERT(upperBound(deltaMap, 22, DeltaTypeSnp()) == end(deltaMap, Standard()));
208 SEQAN_ASSERT_EQ(*upperBound(deltaMap, 4, DeltaTypeIns()), TEntry(5, TRecord(DELTA_TYPE_DEL, 0), cov3, DeltaEndType::IS_BOTH));
209 SEQAN_ASSERT_EQ(*upperBound(deltaMap, 1, DeltaTypeDel()), TEntry(1, TRecord(DELTA_TYPE_SV, 0), cov1, DeltaEndType::IS_LEFT));
210
211 }
212
SEQAN_DEFINE_TEST(test_delta_map_count)213 SEQAN_DEFINE_TEST(test_delta_map_count)
214 {
215 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
216 typedef typename DeltaCoverage<TDeltaMap>::Type TCoverage;
217
218 TDeltaMap deltaMap;
219 createMock(deltaMap);
220
221 TCoverage cov1;
222 _getCoverage(cov1, 10, 3);
223
224 insert(deltaMap, 1, deltaMap._deltaStore._delData[2], cov1, DeltaTypeDel());
225
226 SEQAN_ASSERT_EQ(count(deltaMap, 7, DeltaTypeSnp()), 0u);
227 SEQAN_ASSERT_EQ(count(deltaMap, 4, DeltaTypeIns()), 1u);
228 SEQAN_ASSERT_EQ(count(deltaMap, 1, DeltaTypeDel()), 2u);
229 }
230
SEQAN_DEFINE_TEST(test_delta_map_equal_range)231 SEQAN_DEFINE_TEST(test_delta_map_equal_range)
232 {
233 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
234 typedef typename DeltaCoverage<TDeltaMap>::Type TCoverage;
235
236 TDeltaMap deltaMap;
237 createMock(deltaMap);
238
239 TCoverage cov1;
240 _getCoverage(cov1, 10, 3);
241
242 insert(deltaMap, 1, deltaMap._deltaStore._delData[2], cov1, DeltaTypeDel());
243
244 auto range = equalRange(deltaMap, 7, DeltaTypeSnp());
245 SEQAN_ASSERT(range.i1 == range.i2);
246
247 range = equalRange(deltaMap, 22, DeltaTypeSnp());
248 SEQAN_ASSERT(range.i1 == end(deltaMap, Standard()));
249 SEQAN_ASSERT(range.i2 == end(deltaMap, Standard()));
250
251 range = equalRange(deltaMap, 4, DeltaTypeIns());
252 SEQAN_ASSERT_EQ(*range.i1, *lowerBound(deltaMap, 4, DeltaTypeIns()));
253 SEQAN_ASSERT_EQ(*range.i2, *upperBound(deltaMap, 4, DeltaTypeIns()));
254
255 range = equalRange(deltaMap, 1, DeltaTypeDel());
256 SEQAN_ASSERT_EQ(*range.i1, *lowerBound(deltaMap, 1, DeltaTypeDel()));
257 SEQAN_ASSERT_EQ(*range.i2, *upperBound(deltaMap, 1, DeltaTypeDel()));
258 }
259
SEQAN_DEFINE_TEST(test_delta_map_find)260 SEQAN_DEFINE_TEST(test_delta_map_find)
261 {
262 DeltaMap<TestDeltaMapConfig> deltaMap;
263 createMock(deltaMap);
264
265 SEQAN_ASSERT_EQ(*find(deltaMap, 2, DeltaTypeSnp()), deltaMap._entries[3]);
266 SEQAN_ASSERT_EQ(*find(deltaMap, 1, DeltaTypeSV()), deltaMap._entries[2]);
267 SEQAN_ASSERT_EQ(*find(deltaMap, 20, DeltaTypeDel()), deltaMap._entries[8]);
268 SEQAN_ASSERT(find(deltaMap, 1, DeltaTypeIns()) == end(deltaMap, Standard()));
269 SEQAN_ASSERT(find(deltaMap, 6, DeltaTypeSnp()) == end(deltaMap, Standard()));
270 }
271
SEQAN_DEFINE_TEST(test_delta_map_size)272 SEQAN_DEFINE_TEST(test_delta_map_size)
273 {
274 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
275
276 TDeltaMap deltaMap;
277 SEQAN_ASSERT_EQ(size(deltaMap), 0u);
278 createMock(deltaMap);
279 SEQAN_ASSERT_EQ(size(deltaMap), 10u);
280 }
281
SEQAN_DEFINE_TEST(test_delta_map_empty)282 SEQAN_DEFINE_TEST(test_delta_map_empty)
283 {
284 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
285
286 TDeltaMap deltaMap;
287 SEQAN_ASSERT_EQ(empty(deltaMap), true);
288 createMock(deltaMap);
289 SEQAN_ASSERT_EQ(empty(deltaMap), false);
290 }
291
SEQAN_DEFINE_TEST(test_delta_map_iterator_copy_constructor)292 SEQAN_DEFINE_TEST(test_delta_map_iterator_copy_constructor)
293 {
294 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
295 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
296 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
297
298 TDeltaMap deltaMap;
299 createMock(deltaMap);
300
301 TIterator itMap = begin(deltaMap, Standard());
302
303 TIterator copyItMap = itMap;
304 TConstIterator constCopyItMap = copyItMap;
305 TConstIterator constCopyItMap2 = constCopyItMap;
306
307 SEQAN_ASSERT_EQ(copyItMap._mapPtr, itMap._mapPtr);
308 SEQAN_ASSERT_EQ(copyItMap._mapIter, itMap._mapIter);
309
310 SEQAN_ASSERT_EQ(constCopyItMap._mapPtr, itMap._mapPtr);
311 SEQAN_ASSERT_EQ(constCopyItMap._mapIter, itMap._mapIter);
312
313 SEQAN_ASSERT_EQ(constCopyItMap2._mapPtr, itMap._mapPtr);
314 SEQAN_ASSERT_EQ(constCopyItMap2._mapIter, itMap._mapIter);
315 }
316
SEQAN_DEFINE_TEST(test_delta_map_iterator_assign)317 SEQAN_DEFINE_TEST(test_delta_map_iterator_assign)
318 {
319 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
320 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
321 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
322
323 TDeltaMap deltaMap;
324 createMock(deltaMap);
325
326 TIterator itMap = begin(deltaMap, Standard());
327
328 TIterator copyItMap;
329 TConstIterator constCopyItMap;
330 TConstIterator constCopyItMap2;
331
332 copyItMap = itMap;
333
334 constCopyItMap = copyItMap;
335 constCopyItMap2 = constCopyItMap;
336
337 SEQAN_ASSERT_EQ(copyItMap._mapPtr, itMap._mapPtr);
338 SEQAN_ASSERT_EQ(copyItMap._mapIter, itMap._mapIter);
339
340 SEQAN_ASSERT_EQ(constCopyItMap._mapPtr, itMap._mapPtr);
341 SEQAN_ASSERT_EQ(constCopyItMap._mapIter, itMap._mapIter);
342
343 SEQAN_ASSERT_EQ(constCopyItMap2._mapPtr, itMap._mapPtr);
344 SEQAN_ASSERT_EQ(constCopyItMap2._mapIter, itMap._mapIter);
345 }
346
347 template <typename TMap>
348 inline void
_testDeltaMapIterator(TMap & deltaMap)349 _testDeltaMapIterator(TMap & deltaMap)
350 {
351 typedef typename Iterator<TMap, Standard>::Type TIterator;
352
353 TIterator it = begin(deltaMap, Standard());
354 SEQAN_ASSERT_EQ(getDeltaPosition(*it), 0u);
355
356 unsigned counter = 0;
357 for (; it != end(deltaMap, Standard()); ++it, ++counter)
358 SEQAN_ASSERT_EQ(*(it), deltaMap._entries[counter]);
359 SEQAN_ASSERT_EQ(counter, size(deltaMap));
360
361 for (; it != begin(deltaMap, Standard()); --it, --counter)
362 SEQAN_ASSERT_EQ(*(it - 1), deltaMap._entries[counter - 1]);
363 SEQAN_ASSERT_EQ(counter, 0u);
364
365 for (; !(it == end(deltaMap, Standard())); it++, ++counter)
366 SEQAN_ASSERT_EQ(*(it), deltaMap._entries[counter]);
367 SEQAN_ASSERT_EQ(counter, size(deltaMap));
368
369 for (; !(it == begin(deltaMap, Standard())); it--, --counter)
370 SEQAN_ASSERT_EQ(*(it - 1), deltaMap._entries[counter - 1]);
371 SEQAN_ASSERT_EQ(counter, 0u);
372
373 }
374
SEQAN_DEFINE_TEST(test_delta_map_iterator)375 SEQAN_DEFINE_TEST(test_delta_map_iterator)
376 {
377 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
378
379 TDeltaMap deltaMap;
380 createMock(deltaMap);
381 const TDeltaMap deltaMap2 = deltaMap;
382
383 _testDeltaMapIterator(deltaMap);
384 _testDeltaMapIterator(deltaMap2);
385 }
386
SEQAN_DEFINE_TEST(test_delta_map_iterator_value)387 SEQAN_DEFINE_TEST(test_delta_map_iterator_value)
388 {
389 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
390 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
391 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
392
393 TDeltaMap deltaMap;
394 createMock(deltaMap);
395
396 TIterator it = begin(deltaMap, Standard());
397 SEQAN_ASSERT_EQ(*(it), deltaMap._entries[0]);
398 SEQAN_ASSERT_EQ(*(++it), deltaMap._entries[1]);
399 SEQAN_ASSERT_EQ(*(++it), deltaMap._entries[2]);
400
401 const TDeltaMap deltaMap2 = deltaMap;
402 TConstIterator it2 = begin(deltaMap2, Standard());
403 SEQAN_ASSERT_EQ(*(it2++), deltaMap._entries[0]);
404 SEQAN_ASSERT_EQ(*(it2++), deltaMap._entries[1]);
405 SEQAN_ASSERT_EQ(*(it2), deltaMap._entries[2]);
406 }
407
SEQAN_DEFINE_TEST(test_delta_map_iterator_delta_value)408 SEQAN_DEFINE_TEST(test_delta_map_iterator_delta_value)
409 {
410 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
411 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
412 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
413 typedef DeltaValue<TDeltaMap, DeltaTypeSnp>::Type TSnp;
414 typedef DeltaValue<TDeltaMap, DeltaTypeIns>::Type TIns;
415 typedef DeltaValue<TDeltaMap, DeltaTypeDel>::Type TDel;
416 typedef DeltaValue<TDeltaMap, DeltaTypeSV>::Type TSV;
417
418 TDeltaMap deltaMap;
419 createMock(deltaMap);
420
421 TIterator it = begin(deltaMap, Standard());
422 SEQAN_ASSERT_EQ(deltaValue(it++, DeltaTypeSnp()), TSnp('A'));
423 SEQAN_ASSERT_EQ(deltaValue(it++, DeltaTypeDel()), TDel(3));
424 SEQAN_ASSERT_EQ(deltaValue(it++, DeltaTypeSV()), TSV(2, "TGAT"));
425 it+=3;
426 SEQAN_ASSERT_EQ(deltaValue(it, DeltaTypeIns()), TIns("ACGT"));
427
428 const TDeltaMap deltaMap2 = deltaMap;
429 TConstIterator it2 = begin(deltaMap2, Standard());
430 SEQAN_ASSERT_EQ(deltaValue(it2++, DeltaTypeSnp()), TSnp('A'));
431 SEQAN_ASSERT_EQ(deltaValue(it2++, DeltaTypeDel()), TDel(3));
432 SEQAN_ASSERT_EQ(deltaValue(it2++, DeltaTypeSV()), TSV(2, "TGAT"));
433 it2+=3;
434 SEQAN_ASSERT_EQ(deltaValue(it2, DeltaTypeIns()), TIns("ACGT"));
435 }
436
SEQAN_DEFINE_TEST(test_delta_map_entry_delta_type)437 SEQAN_DEFINE_TEST(test_delta_map_entry_delta_type)
438 {
439 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
440 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
441 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
442
443 TDeltaMap deltaMap;
444 createMock(deltaMap);
445
446 TIterator it = begin(deltaMap, Standard());
447 SEQAN_ASSERT_EQ(getDeltaType(*it), DELTA_TYPE_SNP);
448 SEQAN_ASSERT_EQ(getDeltaType(*++it), DELTA_TYPE_DEL);
449 SEQAN_ASSERT_EQ(getDeltaType(*++it), DELTA_TYPE_SV);
450 SEQAN_ASSERT_EQ(getDeltaType(*++it), DELTA_TYPE_SNP);
451 SEQAN_ASSERT_EQ(getDeltaType(*++it), DELTA_TYPE_SV);
452 SEQAN_ASSERT_EQ(getDeltaType(*(it+2)), DELTA_TYPE_INS);
453
454 const TDeltaMap deltaMap2 = deltaMap;
455 TConstIterator it2 = begin(deltaMap2, Standard());
456 SEQAN_ASSERT_EQ(getDeltaType(*it2++), DELTA_TYPE_SNP);
457 SEQAN_ASSERT_EQ(getDeltaType(*it2++), DELTA_TYPE_DEL);
458 SEQAN_ASSERT_EQ(getDeltaType(*it2++), DELTA_TYPE_SV);
459 SEQAN_ASSERT_EQ(getDeltaType(*it2++), DELTA_TYPE_SNP);
460 SEQAN_ASSERT_EQ(getDeltaType(*it2++), DELTA_TYPE_SV);
461 }
462
SEQAN_DEFINE_TEST(test_delta_map_entry_delta_position)463 SEQAN_DEFINE_TEST(test_delta_map_entry_delta_position)
464 {
465 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
466 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
467 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
468
469 TDeltaMap deltaMap;
470 createMock(deltaMap);
471
472 TIterator it = begin(deltaMap, Standard());
473 SEQAN_ASSERT_EQ(getDeltaPosition(*it), 0u);
474 SEQAN_ASSERT_EQ(getDeltaPosition(*++it), 1u);
475 SEQAN_ASSERT_EQ(getDeltaPosition(*++it), 1u);
476 SEQAN_ASSERT_EQ(getDeltaPosition(*++it), 2u);
477 SEQAN_ASSERT_EQ(getDeltaPosition(*++it), 2u);
478 SEQAN_ASSERT_EQ(getDeltaPosition(*++it), 3u);
479 SEQAN_ASSERT_EQ(getDeltaPosition(*++it), 4u);
480
481 const TDeltaMap deltaMap2 = deltaMap;
482 TConstIterator it2 = begin(deltaMap2, Standard());
483 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 0u);
484 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 1u);
485 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 1u);
486 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 2u);
487 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 2u);
488 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 3u);
489 SEQAN_ASSERT_EQ(getDeltaPosition(*it2++), 4u);
490 }
491
SEQAN_DEFINE_TEST(test_delta_map_entry_delta_coverage)492 SEQAN_DEFINE_TEST(test_delta_map_entry_delta_coverage)
493 {
494 typedef DeltaMap<TestDeltaMapConfig, Default> TDeltaMap;
495 typedef Iterator<TDeltaMap, Standard>::Type TIterator;
496 typedef Iterator<TDeltaMap const, Standard>::Type TConstIterator;
497 typedef DeltaCoverage<TDeltaMap>::Type TCoverage;
498
499 TDeltaMap deltaMap;
500 createMock(deltaMap);
501
502 TCoverage cov1;
503 _getCoverage(cov1, 10, 3);
504 TCoverage cov2;
505 _getCoverage(cov2, 10, 5);
506 TCoverage cov3;
507 _getCoverage(cov3, 10, 2);
508
509 TIterator it = begin(deltaMap, Standard());
510 SEQAN_ASSERT_EQ(getDeltaCoverage(*it++), cov1);
511 SEQAN_ASSERT_EQ(getDeltaCoverage(*it++), cov2);
512 SEQAN_ASSERT_EQ(getDeltaCoverage(*it++), cov1);
513 SEQAN_ASSERT_EQ(getDeltaCoverage(*it++), cov2);
514 SEQAN_ASSERT_EQ(getDeltaCoverage(*it++), cov1);
515 SEQAN_ASSERT_EQ(getDeltaCoverage(*(it+2)), cov3);
516
517 const TDeltaMap deltaMap2 = deltaMap;
518 TConstIterator it2 = begin(deltaMap2, Standard());
519 SEQAN_ASSERT_EQ(getDeltaCoverage(*it2++), cov1);
520 SEQAN_ASSERT_EQ(getDeltaCoverage(*it2++), cov2);
521 SEQAN_ASSERT_EQ(getDeltaCoverage(*it2++), cov1);
522 SEQAN_ASSERT_EQ(getDeltaCoverage(*it2++), cov2);
523 SEQAN_ASSERT_EQ(getDeltaCoverage(*it2++), cov1);
524 SEQAN_ASSERT_EQ(getDeltaCoverage(*(it2+2)), cov3);
525 }
526
527 #endif // TESTS_JOURNALED_STRING_TREE_TEST_DELTA_MAP_H_
528