libStatGen Software 1
CigarRollerTest.cpp
1/*
2 * Copyright (C) 2010 Regents of the University of Michigan
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18
19// put TEST below here, so that makedepend will see the .h, so that we
20// can get a clean dependency for SmithWaterman.o, so that we can at least
21// compile the header when we change it.
22
23
24#include <getopt.h>
25#include "Generic.h"
26#include "CigarRollerTest.h"
27
28//
29// Test the obvious cases.
30// Add non-obvious ones as bugs come up.
31//
32int CigarRollerTest::test(void)
33{
34 int failures = 0, testNum = 0;
36
37 // const char *str;
38 ////////////////////////////////////
39 // Test foundInReference static methods.
40 check(failures, ++testNum, "foundInReference(none)", false,
42 check(failures, ++testNum, "foundInReference(match)", true,
44 check(failures, ++testNum, "foundInReference(mismatch)", true,
46 check(failures, ++testNum, "foundInReference(insert)", false,
48 check(failures, ++testNum, "foundInReference(del)", true,
50 check(failures, ++testNum, "foundInReference(skip)", true,
52 check(failures, ++testNum, "foundInReference(softClip)", false,
54 check(failures, ++testNum, "foundInReference(hardClip)", false,
56 check(failures, ++testNum, "foundInReference(pad)", false,
58
59 check(failures, ++testNum,
60 "foundInReference('?')", false, Cigar::foundInReference('?'));
61 check(failures, ++testNum,
62 "foundInReference('z')", false, Cigar::foundInReference('z'));
63 check(failures, ++testNum,
64 "foundInReference('M')", true, Cigar::foundInReference('M'));
65 check(failures, ++testNum,
66 "foundInReference('X')", true, Cigar::foundInReference('X'));
67 check(failures, ++testNum,
68 "foundInReference('=')", true, Cigar::foundInReference('='));
69 check(failures, ++testNum,
70 "foundInReference('I')", false, Cigar::foundInReference('I'));
71 check(failures, ++testNum,
72 "foundInReference('D')", true, Cigar::foundInReference('D'));
73 check(failures, ++testNum,
74 "foundInReference('N')", true, Cigar::foundInReference('N'));
75 check(failures, ++testNum,
76 "foundInReference('S')", false, Cigar::foundInReference('S'));
77 check(failures, ++testNum,
78 "foundInReference('H')", false, Cigar::foundInReference('H'));
79 check(failures, ++testNum,
80 "foundInReference('P')", false, Cigar::foundInReference('P'));
81
82 op.count = 3;
83 op.operation = Cigar::none;
84 check(failures, ++testNum, "foundInReference(none)", false,
86 op.operation = Cigar::match;
87 check(failures, ++testNum, "foundInReference(match)", true,
89 op.operation = Cigar::mismatch;
90 check(failures, ++testNum, "foundInReference(mismatch)", true,
92 op.operation = Cigar::insert;
93 check(failures, ++testNum, "foundInReference(insert)", false,
95 op.operation = Cigar::del;
96 check(failures, ++testNum, "foundInReference(del)", true,
98 op.operation = Cigar::skip;
99 check(failures, ++testNum, "foundInReference(skip)", true,
101 op.operation = Cigar::softClip;
102 check(failures, ++testNum, "foundInReference(softClip)", false,
104 op.operation = Cigar::hardClip;
105 check(failures, ++testNum, "foundInReference(hardClip)", false,
107 op.operation = Cigar::pad;
108 check(failures, ++testNum, "foundInReference(pad)", false,
110
111 ////////////////////////////////////
112 // Test foundInQuery static methods.
113 check(failures, ++testNum, "foundInQuery(none)", false,
115 check(failures, ++testNum, "foundInQuery(match)", true,
117 check(failures, ++testNum, "foundInQuery(mismatch)", true,
119 check(failures, ++testNum, "foundInQuery(insert)", true,
121 check(failures, ++testNum, "foundInQuery(del)", false,
123 check(failures, ++testNum, "foundInQuery(skip)", false,
125 check(failures, ++testNum, "foundInQuery(softClip)", true,
127 check(failures, ++testNum, "foundInQuery(hardClip)", false,
129 check(failures, ++testNum, "foundInQuery(pad)", false,
131
132 check(failures, ++testNum,
133 "foundInQuery('?')", false, Cigar::foundInQuery('?'));
134 check(failures, ++testNum,
135 "foundInQuery('z')", false, Cigar::foundInQuery('z'));
136 check(failures, ++testNum,
137 "foundInQuery('M')", true, Cigar::foundInQuery('M'));
138 check(failures, ++testNum,
139 "foundInQuery('X')", true, Cigar::foundInQuery('X'));
140 check(failures, ++testNum,
141 "foundInQuery('=')", true, Cigar::foundInQuery('='));
142 check(failures, ++testNum,
143 "foundInQuery('I')", true, Cigar::foundInQuery('I'));
144 check(failures, ++testNum,
145 "foundInQuery('D')", false, Cigar::foundInQuery('D'));
146 check(failures, ++testNum,
147 "foundInQuery('N')", false, Cigar::foundInQuery('N'));
148 check(failures, ++testNum,
149 "foundInQuery('S')", true, Cigar::foundInQuery('S'));
150 check(failures, ++testNum,
151 "foundInQuery('H')", false, Cigar::foundInQuery('H'));
152 check(failures, ++testNum,
153 "foundInQuery('P')", false, Cigar::foundInQuery('P'));
154
155 op.count = 3;
156 op.operation = Cigar::none;
157 check(failures, ++testNum, "foundInQuery(none)", false,
159 op.operation = Cigar::match;
160 check(failures, ++testNum, "foundInQuery(match)", true,
162 op.operation = Cigar::mismatch;
163 check(failures, ++testNum, "foundInQuery(mismatch)", true,
165 op.operation = Cigar::insert;
166 check(failures, ++testNum, "foundInQuery(insert)", true,
168 op.operation = Cigar::del;
169 check(failures, ++testNum, "foundInQuery(del)", false,
171 op.operation = Cigar::skip;
172 check(failures, ++testNum, "foundInQuery(skip)", false,
174 op.operation = Cigar::softClip;
175 check(failures, ++testNum, "foundInQuery(softClip)", true,
177 op.operation = Cigar::hardClip;
178 check(failures, ++testNum, "foundInQuery(hardClip)", false,
180 op.operation = Cigar::pad;
181 check(failures, ++testNum, "foundInQuery(pad)", false,
183
184
185 ////////////////////////////////////
186 // Test isClip static methods.
187 check(failures, ++testNum, "isClip(none)", false,
189 check(failures, ++testNum, "isClip(match)", false,
191 check(failures, ++testNum, "isClip(mismatch)", false,
193 check(failures, ++testNum, "isClip(insert)", false,
195 check(failures, ++testNum, "isClip(del)", false,
197 check(failures, ++testNum, "isClip(skip)", false,
199 check(failures, ++testNum, "isClip(softClip)", true,
201 check(failures, ++testNum, "isClip(hardClip)", true,
203 check(failures, ++testNum, "isClip(pad)", false,
205
206 check(failures, ++testNum,
207 "isClip('?')", false, Cigar::isClip('?'));
208 check(failures, ++testNum,
209 "isClip('z')", false, Cigar::isClip('z'));
210 check(failures, ++testNum,
211 "isClip('M')", false, Cigar::isClip('M'));
212 check(failures, ++testNum,
213 "isClip('X')", false, Cigar::isClip('X'));
214 check(failures, ++testNum,
215 "isClip('=')", false, Cigar::isClip('='));
216 check(failures, ++testNum,
217 "isClip('I')", false, Cigar::isClip('I'));
218 check(failures, ++testNum,
219 "isClip('D')", false, Cigar::isClip('D'));
220 check(failures, ++testNum,
221 "isClip('N')", false, Cigar::isClip('N'));
222 check(failures, ++testNum,
223 "isClip('S')", true, Cigar::isClip('S'));
224 check(failures, ++testNum,
225 "isClip('H')", true, Cigar::isClip('H'));
226 check(failures, ++testNum,
227 "isClip('P')", false, Cigar::isClip('P'));
228
229 op.count = 3;
230 op.operation = Cigar::none;
231 check(failures, ++testNum, "isClip(none)", false,
232 Cigar::isClip(op));
233 op.operation = Cigar::match;
234 check(failures, ++testNum, "isClip(match)", false,
235 Cigar::isClip(op));
236 op.operation = Cigar::mismatch;
237 check(failures, ++testNum, "isClip(mismatch)", false,
238 Cigar::isClip(op));
239 op.operation = Cigar::insert;
240 check(failures, ++testNum, "isClip(insert)", false,
241 Cigar::isClip(op));
242 op.operation = Cigar::del;
243 check(failures, ++testNum, "isClip(del)", false,
244 Cigar::isClip(op));
245 op.operation = Cigar::skip;
246 check(failures, ++testNum, "isClip(skip)", false,
247 Cigar::isClip(op));
248 op.operation = Cigar::softClip;
249 check(failures, ++testNum, "isClip(softClip)", true,
250 Cigar::isClip(op));
251 op.operation = Cigar::hardClip;
252 check(failures, ++testNum, "isClip(hardClip)", true,
253 Cigar::isClip(op));
254 op.operation = Cigar::pad;
255 check(failures, ++testNum, "isClip(pad)", false,
256 Cigar::isClip(op));
257
258
259
260
261
262
263 ///////////////////////////////
264
265 // Create the CigarRoller.
266 CigarRoller cigar;
267
268 // const char *str;
269 String str;
270 std::string result;
271
272 cigar.getCigarString(str);
273 result = str.c_str();
274 // result = str = cigar.getString(); delete str;
275
276 check(failures, ++testNum, "constructor", result, ""); // test empty case
277
278 op.operation = CigarRoller::match;
279 op.count = 10;
280
281 cigar += op;
282
283 op.count=5;
284
285 cigar += op;
286
287 op.count=5; op.operation = CigarRoller::mismatch; // test that match/mismatch get combined
288
289 cigar += op;
290
291 op.count=5; op.operation = CigarRoller::insert;
292
293 cigar += op;
294
295 op.count=5; op.operation = CigarRoller::insert;
296
297 cigar += op;
298
299 op.count=5; op.operation = CigarRoller::del;
300
301 cigar += op;
302
303 op.count=5; op.operation = CigarRoller::mismatch;
304
305 cigar += op;
306
307 op.count=5; op.operation = CigarRoller::match;
308
309 cigar += op;
310
311 op.count=5; op.operation = CigarRoller::skip;
312
313 cigar += op;
314
315 op.count=5; op.operation = CigarRoller::match;
316
317 cigar += op;
318
319 op.count=2; op.operation = CigarRoller::pad;
320
321 cigar += op;
322
323 op.count=3; op.operation = CigarRoller::match;
324
325 cigar += op;
326
327 cigar.getCigarString(str);
328 result = str.c_str();
329 // result = str = cigar.getString(); delete str;
330
331 check(failures, ++testNum, "match combining", "20M10I5D10M5N5M2P3M", result);
332 check(failures, ++testNum, "length check", 8, cigar.size());
333
334 //////////////////////////////////////////////////////////////////////////////////////////////////////////
335 // Test getRefOffset, getQueryIndex, getRefPosition, & getQueryIndex(that takes ref position)
336
337 // Validate the reference offsets when passing in a query index,
338 // and the query offsets when passing in a query index.
339 // Spot check the offsets out of order - to verify order doesn't matter.
340 check(failures, ++testNum, "getRefOffset(20)", -1, cigar.getRefOffset(20));
341 check(failures, ++testNum, "getRefOffset(30)", 25, cigar.getRefOffset(30));
342 check(failures, ++testNum, "getRefOffset(46)", 46, cigar.getRefOffset(46));
343 check(failures, ++testNum, "getRefOffset(0)", 0, cigar.getRefOffset(0));
344 check(failures, ++testNum, "getRefPosition(20, 5)", -1, cigar.getRefPosition(20, 5));
345 check(failures, ++testNum, "getRefPosition(30, 5)", 30, cigar.getRefPosition(30, 5));
346 check(failures, ++testNum, "getRefPosition(46, 5)", 51, cigar.getRefPosition(46, 5));
347 check(failures, ++testNum, "getRefPosition(0, 5)", 5, cigar.getRefPosition(0, 5));
348 check(failures, ++testNum, "getQueryIndex(20)", CigarRoller::INDEX_NA, cigar.getQueryIndex(20));
349 check(failures, ++testNum, "getQueryIndex(30)", 35, cigar.getQueryIndex(30));
350 check(failures, ++testNum, "getQueryIndex(35)", Cigar::INDEX_NA, cigar.getQueryIndex(35));
351 check(failures, ++testNum, "getQueryIndex(46)", 46, cigar.getQueryIndex(46));
352 check(failures, ++testNum, "getQueryIndex(0)", 0, cigar.getQueryIndex(0));
353 check(failures, ++testNum, "getQueryIndex(25, 5)", -1, cigar.getQueryIndex(20));
354 check(failures, ++testNum, "getQueryIndex(35, 5)", 35, cigar.getQueryIndex(30));
355 check(failures, ++testNum, "getQueryIndex(40, 5)", -1, cigar.getQueryIndex(35));
356 check(failures, ++testNum, "getQueryIndex(51, 5)", 46, cigar.getQueryIndex(46));
357 check(failures, ++testNum, "getQueryIndex(5, 5)", 0, cigar.getQueryIndex(0));
358
359 int i = 0;
360 int queryIndex = 0;
361 int refOffset = 0;
362 // Validate the 20 matches.
363 for(i = 0; i < 20; i++)
364 {
365 check(failures, ++testNum, "getRefOffset(queryIndex)", refOffset, cigar.getRefOffset(queryIndex));
366 check(failures, ++testNum, "getQueryIndex(refOffset)", queryIndex, cigar.getQueryIndex(refOffset));
367 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", refOffset + 5, cigar.getRefPosition(queryIndex, 5));
368 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", queryIndex, cigar.getQueryIndex(refOffset + 5, 5));
369 ++queryIndex;
370 ++refOffset;
371 }
372 // Validate the 10 Inserts - exist in query, but not in the reference.
373 for(i = 0; i < 10; i++)
374 {
375 check(failures, ++testNum, "getRefOffset(queryIndex)", -1, cigar.getRefOffset(queryIndex));
376 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", -1, cigar.getRefPosition(queryIndex, 5));
377 ++queryIndex;
378 }
379 // Validate the 5 Deletions - exist in the reference, but not the query.
380 for(i = 0; i < 5; i++)
381 {
382 check(failures, ++testNum, "getQueryIndex(refOffset)", -1, cigar.getQueryIndex(refOffset));
383 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", -1, cigar.getQueryIndex(refOffset + 5, 5));
384 refOffset++;
385 }
386 // Validate the 10 matches.
387 for(i = 0; i < 10; i++)
388 {
389 check(failures, ++testNum, "getRefOffset(queryIndex)", refOffset, cigar.getRefOffset(queryIndex));
390 check(failures, ++testNum, "getQueryIndex(refOffset)", queryIndex, cigar.getQueryIndex(refOffset));
391 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", refOffset + 5, cigar.getRefPosition(queryIndex, 5));
392 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", queryIndex, cigar.getQueryIndex(refOffset + 5, 5));
393 ++queryIndex;
394 ++refOffset;
395 }
396 // Validate the 5 Skips - exist in the reference, but not the query.
397 for(i = 0; i < 5; i++)
398 {
399 check(failures, ++testNum, "getQueryIndex(refOffset)", -1, cigar.getQueryIndex(refOffset));
400 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", -1, cigar.getQueryIndex(refOffset + 5, 5));
401 refOffset++;
402 }
403 // Validate the 5 matches.
404 for(i = 0; i < 5; i++)
405 {
406 check(failures, ++testNum, "getRefOffset(queryIndex)", refOffset, cigar.getRefOffset(queryIndex));
407 check(failures, ++testNum, "getQueryIndex(refOffset)", queryIndex, cigar.getQueryIndex(refOffset));
408 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", refOffset + 5, cigar.getRefPosition(queryIndex, 5));
409 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", queryIndex, cigar.getQueryIndex(refOffset + 5, 5));
410 ++queryIndex;
411 ++refOffset;
412 }
413 // Nothing to validate for the 2 pads since they do not show up in either the reference or the query.
414 // Validate the 3 matches.
415 for(i = 0; i < 3; i++)
416 {
417 check(failures, ++testNum, "getRefOffset(queryIndex)", refOffset, cigar.getRefOffset(queryIndex));
418 check(failures, ++testNum, "getQueryIndex(refOffset)", queryIndex, cigar.getQueryIndex(refOffset));
419 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", refOffset + 5, cigar.getRefPosition(queryIndex, 5));
420 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", queryIndex, cigar.getQueryIndex(refOffset + 5, 5));
421 ++queryIndex;
422 ++refOffset;
423 }
424
425 // Validate that if you go beyond the end, -1 is returned.
426 check(failures, ++testNum, "getRefOffset(queryIndex)", -1, cigar.getRefOffset(queryIndex));
427 check(failures, ++testNum, "getQueryIndex(refOffset)", -1, cigar.getQueryIndex(refOffset));
428 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", -1, cigar.getRefPosition(queryIndex, 5));
429 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", -1, cigar.getQueryIndex(refOffset + 5, 5));
430 ++queryIndex;
431 ++refOffset;
432 check(failures, ++testNum, "getRefOffset(queryIndex)", -1, cigar.getRefOffset(queryIndex));
433 check(failures, ++testNum, "getQueryIndex(refOffset)", -1, cigar.getQueryIndex(refOffset));
434 check(failures, ++testNum, "getRefPosition(queryIndex, 5)", -1, cigar.getRefPosition(queryIndex, 5));
435 check(failures, ++testNum, "getQueryIndex(refPosition, 5)", -1, cigar.getQueryIndex(refOffset + 5, 5));
436
437 ////////////////////////////////////////////////////////////////////////
438 // Test getNumOverlaps
439
440 // When query starts at position 5:
441 // Overlaps are at 5-24, 30-39, 45-49, 50-52
442
443 // Test with region [1-5) where query starts at position 5 = 0 overlaps.
444 check(failures, ++testNum, "getNumOverlaps(1, 5, 5)", (uint32_t)0, cigar.getNumOverlaps(1, 5, 5));
445
446 // Test with region [53-101) where query starts at position 5 = 0 overlaps.
447 check(failures, ++testNum, "getNumOverlaps(53, 101, 5)", (uint32_t)0, cigar.getNumOverlaps(53, 101, 5));
448
449 // Test with region [53-10) where query starts at position 5 = 0 overlaps.
450 check(failures, ++testNum, "getNumOverlaps(53, 10, 5)", (uint32_t)0, cigar.getNumOverlaps(53, 10, 5));
451
452 // Test with region [35-10) where query starts at position 5 = 0 overlaps.
453 check(failures, ++testNum, "getNumOverlaps(35, 10, 5)", (uint32_t)0, cigar.getNumOverlaps(35, 10, 5));
454
455 // Test with region [35-1) where query starts at position 5 = 0 overlaps.
456 check(failures, ++testNum, "getNumOverlaps(35, 1, 5)", (uint32_t)0, cigar.getNumOverlaps(35, 1, 5));
457
458 // Test with region [1-6) where query starts at position 5 - 1 overlap = pos 5.
459 check(failures, ++testNum, "getNumOverlaps(1, 6, 5)", (uint32_t)1, cigar.getNumOverlaps(1, 6, 5));
460
461 // Test with region [25-30) where query has only DELETIONS from the reference = 0 overlaps.
462 check(failures, ++testNum, "getNumOverlaps(25, 30, 5)", (uint32_t)0, cigar.getNumOverlaps(25, 30, 5));
463
464 // Test with region [24-30) where query has only a match at position 24 = 1 overlap.
465 check(failures, ++testNum, "getNumOverlaps(24, 30, 5)", (uint32_t)1, cigar.getNumOverlaps(24, 30, 5));
466
467 // Test with region [25-31) where query has only a match at position 30 = 1 overlap.
468 check(failures, ++testNum, "getNumOverlaps(25, 31, 5)", (uint32_t)1, cigar.getNumOverlaps(25, 31, 5));
469
470 // Test with region [1-31), match pos 5-24 & 30 = 21 overlaps
471 check(failures, ++testNum, "getNumOverlaps(1, 31, 5)", (uint32_t)21, cigar.getNumOverlaps(1, 31, 5));
472
473 // Test a region that covers the entire range [1-101), match pos 5-24, 30-39, 45-49, & 50-52 = 38 overlaps
474 check(failures, ++testNum, "getNumOverlaps(1, 101, 5)", (uint32_t)38, cigar.getNumOverlaps(1, 101, 5));
475
476 // Test a region that covers the entire range [-1--1), (whole region) match pos 5-24, 30-39, 45-49, & 50-52 = 38 overlaps
477 check(failures, ++testNum, "getNumOverlaps(-1, -1, 5)", (uint32_t)38, cigar.getNumOverlaps(-1, -1, 5));
478
479 // Test a region that covers the entire range [6-52), match pos 6-24, 30-39, 45-49, & 50-51 = 36 overlaps
480 check(failures, ++testNum, "getNumOverlaps(6, 52, 5)", (uint32_t)36, cigar.getNumOverlaps(6, 52, 5));
481
482 // Test with region [40-45) where query has only SKIPS from the reference = 0 overlaps.
483 check(failures, ++testNum, "getNumOverlaps(40, 45, 5)", (uint32_t)0, cigar.getNumOverlaps(40, 45, 5));
484
485 // Test a region that covers the range [-1-10), (whole region) match pos 5-9 = 5 overlaps
486 check(failures, ++testNum, "getNumOverlaps(-1, 10, 5)", (uint32_t)5, cigar.getNumOverlaps(-1, 10, 5));
487
488 // Test a region that covers the range [50--1), (whole region) match pos 50-52 = 3 overlaps
489 check(failures, ++testNum, "getNumOverlaps(50, -1, 5)", (uint32_t)3, cigar.getNumOverlaps(50, -1, 5));
490
491 ////////////////////////////////////////////////////////////////////////////
492 // Test a new CIGAR.
493 cigar.Set("4M10N4M3I2M4D3M");
494 String expectedResult = "4M10N4M3I2M4D3M";
495 String cigarString = "HI";
496 cigar.getCigarString(cigarString);
497 check(failures, ++testNum, "getCigarString", expectedResult, cigarString);
498
499 // 4M10N4M3I2M4D3M
500 // 11111111112222222222
501 // ExtIndex: 012345678901234567890123456789
502 // ExtCigar: MMMMNNNNNNNNNNMMMMIIIMMDDDDMMM
503 // 111 111
504 // QueryIndx:0123 456789012 345
505 // 11111111 112222222
506 // RefOffset:012345678901234567 890123456
507 // 1111111111222 222222233
508 // RefPos: 567890123456789012 345678901
509
510 // Test getExpandedCigarIndex & getCigar op
511 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(0, 5)", -1, cigar.getExpandedCigarIndexFromRefPos(0,5));
512 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(1, 5)", -1, cigar.getExpandedCigarIndexFromRefPos(1,5));
513 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(2, 5)", -1, cigar.getExpandedCigarIndexFromRefPos(2,5));
514 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(3, 5)", -1, cigar.getExpandedCigarIndexFromRefPos(3,5));
515 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(4, 5)", -1, cigar.getExpandedCigarIndexFromRefPos(4,5));
516 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(5, 5)", 0, cigar.getExpandedCigarIndexFromRefPos(5,5));
517 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(6, 5)", 1, cigar.getExpandedCigarIndexFromRefPos(6,5));
518 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(7, 5)", 2, cigar.getExpandedCigarIndexFromRefPos(7,5));
519 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(8, 5)", 3, cigar.getExpandedCigarIndexFromRefPos(8,5));
520 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(9, 5)", 4, cigar.getExpandedCigarIndexFromRefPos(9,5));
521 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(10, 5)", 5, cigar.getExpandedCigarIndexFromRefPos(10,5));
522 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(11, 5)", 6, cigar.getExpandedCigarIndexFromRefPos(11,5));
523 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(12, 5)", 7, cigar.getExpandedCigarIndexFromRefPos(12,5));
524 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(13, 5)", 8, cigar.getExpandedCigarIndexFromRefPos(13,5));
525 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(14, 5)", 9, cigar.getExpandedCigarIndexFromRefPos(14,5));
526 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(15, 5)", 10, cigar.getExpandedCigarIndexFromRefPos(15,5));
527 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(16, 5)", 11, cigar.getExpandedCigarIndexFromRefPos(16,5));
528 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(17, 5)", 12, cigar.getExpandedCigarIndexFromRefPos(17,5));
529 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(18, 5)", 13, cigar.getExpandedCigarIndexFromRefPos(18,5));
530 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(19, 5)", 14, cigar.getExpandedCigarIndexFromRefPos(19,5));
531 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(20, 5)", 15, cigar.getExpandedCigarIndexFromRefPos(20,5));
532 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(21, 5)", 16, cigar.getExpandedCigarIndexFromRefPos(21,5));
533 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(22, 5)", 17, cigar.getExpandedCigarIndexFromRefPos(22,5));
534 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(23, 5)", 21, cigar.getExpandedCigarIndexFromRefPos(23,5));
535 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(24, 5)", 22, cigar.getExpandedCigarIndexFromRefPos(24,5));
536 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(25, 5)", 23, cigar.getExpandedCigarIndexFromRefPos(25,5));
537 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(26, 5)", 24, cigar.getExpandedCigarIndexFromRefPos(26,5));
538 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(27, 5)", 25, cigar.getExpandedCigarIndexFromRefPos(27,5));
539 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(28, 5)", 26, cigar.getExpandedCigarIndexFromRefPos(28,5));
540 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(29, 5)", 27, cigar.getExpandedCigarIndexFromRefPos(29,5));
541 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(30, 5)", 28, cigar.getExpandedCigarIndexFromRefPos(30,5));
542 check(failures, ++testNum, "getExpandedCigarIndexFromRefPos(31, 5)", 29, cigar.getExpandedCigarIndexFromRefPos(31,5));
543
544 //
545 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(0)", 0, cigar.getExpandedCigarIndexFromRefOffset(0));
546 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(1)", 1, cigar.getExpandedCigarIndexFromRefOffset(1));
547 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(2)", 2, cigar.getExpandedCigarIndexFromRefOffset(2));
548 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(3)", 3, cigar.getExpandedCigarIndexFromRefOffset(3));
549 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(4)", 4, cigar.getExpandedCigarIndexFromRefOffset(4));
550 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(5)", 5, cigar.getExpandedCigarIndexFromRefOffset(5));
551 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(6)", 6, cigar.getExpandedCigarIndexFromRefOffset(6));
552 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(7)", 7, cigar.getExpandedCigarIndexFromRefOffset(7));
553 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(8)", 8, cigar.getExpandedCigarIndexFromRefOffset(8));
554 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(9)", 9, cigar.getExpandedCigarIndexFromRefOffset(9));
555 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(10)", 10, cigar.getExpandedCigarIndexFromRefOffset(10));
556 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(11)", 11, cigar.getExpandedCigarIndexFromRefOffset(11));
557 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(12)", 12, cigar.getExpandedCigarIndexFromRefOffset(12));
558 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(13)", 13, cigar.getExpandedCigarIndexFromRefOffset(13));
559 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(14)", 14, cigar.getExpandedCigarIndexFromRefOffset(14));
560 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(15)", 15, cigar.getExpandedCigarIndexFromRefOffset(15));
561 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(16)", 16, cigar.getExpandedCigarIndexFromRefOffset(16));
562 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(17)", 17, cigar.getExpandedCigarIndexFromRefOffset(17));
563 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(18)", 21, cigar.getExpandedCigarIndexFromRefOffset(18));
564 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(19)", 22, cigar.getExpandedCigarIndexFromRefOffset(19));
565 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(20)", 23, cigar.getExpandedCigarIndexFromRefOffset(20));
566 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(21)", 24, cigar.getExpandedCigarIndexFromRefOffset(21));
567 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(22)", 25, cigar.getExpandedCigarIndexFromRefOffset(22));
568 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(23)", 26, cigar.getExpandedCigarIndexFromRefOffset(23));
569 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(24)", 27, cigar.getExpandedCigarIndexFromRefOffset(24));
570 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(25)", 28, cigar.getExpandedCigarIndexFromRefOffset(25));
571 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(26)", 29, cigar.getExpandedCigarIndexFromRefOffset(26));
572 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(27)", -1, cigar.getExpandedCigarIndexFromRefOffset(27));
573 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(28)", -1, cigar.getExpandedCigarIndexFromRefOffset(28));
574 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(29)", -1, cigar.getExpandedCigarIndexFromRefOffset(29));
575 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(30)", -1, cigar.getExpandedCigarIndexFromRefOffset(30));
576 check(failures, ++testNum, "getExpandedCigarIndexFromRefOffset(31)", -1, cigar.getExpandedCigarIndexFromRefOffset(31));
577
578 //
579 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(0)", 0, cigar.getExpandedCigarIndexFromQueryIndex(0));
580 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(1)", 1, cigar.getExpandedCigarIndexFromQueryIndex(1));
581 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(2)", 2, cigar.getExpandedCigarIndexFromQueryIndex(2));
582 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(3)", 3, cigar.getExpandedCigarIndexFromQueryIndex(3));
583 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(4)", 14, cigar.getExpandedCigarIndexFromQueryIndex(4));
584 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(5)", 15, cigar.getExpandedCigarIndexFromQueryIndex(5));
585 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(6)", 16, cigar.getExpandedCigarIndexFromQueryIndex(6));
586 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(7)", 17, cigar.getExpandedCigarIndexFromQueryIndex(7));
587 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(8)", 18, cigar.getExpandedCigarIndexFromQueryIndex(8));
588 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(9)", 19, cigar.getExpandedCigarIndexFromQueryIndex(9));
589 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(10)", 20, cigar.getExpandedCigarIndexFromQueryIndex(10));
590 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(11)", 21, cigar.getExpandedCigarIndexFromQueryIndex(11));
591 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(12)", 22, cigar.getExpandedCigarIndexFromQueryIndex(12));
592 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(13)", 27, cigar.getExpandedCigarIndexFromQueryIndex(13));
593 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(14)", 28, cigar.getExpandedCigarIndexFromQueryIndex(14));
594 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(15)", 29, cigar.getExpandedCigarIndexFromQueryIndex(15));
595 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(16)", -1, cigar.getExpandedCigarIndexFromQueryIndex(16));
596 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(17)", -1, cigar.getExpandedCigarIndexFromQueryIndex(17));
597 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(18)", -1, cigar.getExpandedCigarIndexFromQueryIndex(18));
598 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(19)", -1, cigar.getExpandedCigarIndexFromQueryIndex(19));
599 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(20)", -1, cigar.getExpandedCigarIndexFromQueryIndex(20));
600 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(21)", -1, cigar.getExpandedCigarIndexFromQueryIndex(21));
601 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(22)", -1, cigar.getExpandedCigarIndexFromQueryIndex(22));
602 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(23)", -1, cigar.getExpandedCigarIndexFromQueryIndex(23));
603 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(24)", -1, cigar.getExpandedCigarIndexFromQueryIndex(24));
604 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(25)", -1, cigar.getExpandedCigarIndexFromQueryIndex(25));
605 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(26)", -1, cigar.getExpandedCigarIndexFromQueryIndex(26));
606 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(27)", -1, cigar.getExpandedCigarIndexFromQueryIndex(27));
607 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(28)", -1, cigar.getExpandedCigarIndexFromQueryIndex(28));
608 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(29)", -1, cigar.getExpandedCigarIndexFromQueryIndex(29));
609 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(30)", -1, cigar.getExpandedCigarIndexFromQueryIndex(30));
610 check(failures, ++testNum, "getExpandedCigarIndexFromQueryIndex(31)", -1, cigar.getExpandedCigarIndexFromQueryIndex(31));
611
612 // Test getCigarCharOp.
613 check(failures, ++testNum, "getCigarCharOp(-1)", '?', cigar.getCigarCharOp(-1));
614 check(failures, ++testNum, "getCigarCharOp(0)", 'M', cigar.getCigarCharOp(0));
615 check(failures, ++testNum, "getCigarCharOp(1)", 'M', cigar.getCigarCharOp(1));
616 check(failures, ++testNum, "getCigarCharOp(2)", 'M', cigar.getCigarCharOp(2));
617 check(failures, ++testNum, "getCigarCharOp(3)", 'M', cigar.getCigarCharOp(3));
618 check(failures, ++testNum, "getCigarCharOp(4)", 'N', cigar.getCigarCharOp(4));
619 check(failures, ++testNum, "getCigarCharOp(5)", 'N', cigar.getCigarCharOp(5));
620 check(failures, ++testNum, "getCigarCharOp(6)", 'N', cigar.getCigarCharOp(6));
621 check(failures, ++testNum, "getCigarCharOp(7)", 'N', cigar.getCigarCharOp(7));
622 check(failures, ++testNum, "getCigarCharOp(8)", 'N', cigar.getCigarCharOp(8));
623 check(failures, ++testNum, "getCigarCharOp(9)", 'N', cigar.getCigarCharOp(9));
624 check(failures, ++testNum, "getCigarCharOp(10)", 'N', cigar.getCigarCharOp(10));
625 check(failures, ++testNum, "getCigarCharOp(11)", 'N', cigar.getCigarCharOp(11));
626 check(failures, ++testNum, "getCigarCharOp(12)", 'N', cigar.getCigarCharOp(12));
627 check(failures, ++testNum, "getCigarCharOp(13)", 'N', cigar.getCigarCharOp(13));
628 check(failures, ++testNum, "getCigarCharOp(14)", 'M', cigar.getCigarCharOp(14));
629 check(failures, ++testNum, "getCigarCharOp(15)", 'M', cigar.getCigarCharOp(15));
630 check(failures, ++testNum, "getCigarCharOp(16)", 'M', cigar.getCigarCharOp(16));
631 check(failures, ++testNum, "getCigarCharOp(17)", 'M', cigar.getCigarCharOp(17));
632 check(failures, ++testNum, "getCigarCharOp(18)", 'I', cigar.getCigarCharOp(18));
633 check(failures, ++testNum, "getCigarCharOp(19)", 'I', cigar.getCigarCharOp(19));
634 check(failures, ++testNum, "getCigarCharOp(20)", 'I', cigar.getCigarCharOp(20));
635 check(failures, ++testNum, "getCigarCharOp(21)", 'M', cigar.getCigarCharOp(21));
636 check(failures, ++testNum, "getCigarCharOp(22)", 'M', cigar.getCigarCharOp(22));
637 check(failures, ++testNum, "getCigarCharOp(23)", 'D', cigar.getCigarCharOp(23));
638 check(failures, ++testNum, "getCigarCharOp(24)", 'D', cigar.getCigarCharOp(24));
639 check(failures, ++testNum, "getCigarCharOp(25)", 'D', cigar.getCigarCharOp(25));
640 check(failures, ++testNum, "getCigarCharOp(26)", 'D', cigar.getCigarCharOp(26));
641 check(failures, ++testNum, "getCigarCharOp(27)", 'M', cigar.getCigarCharOp(27));
642 check(failures, ++testNum, "getCigarCharOp(28)", 'M', cigar.getCigarCharOp(28));
643 check(failures, ++testNum, "getCigarCharOp(29)", 'M', cigar.getCigarCharOp(29));
644 check(failures, ++testNum, "getCigarCharOp(30)", '?', cigar.getCigarCharOp(30));
645
646
647 // Test getCigarCharOpFromQueryIndex.
648 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(-1)", '?', cigar.getCigarCharOpFromQueryIndex(-1));
649 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(0)", 'M', cigar.getCigarCharOpFromQueryIndex(0));
650 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(1)", 'M', cigar.getCigarCharOpFromQueryIndex(1));
651 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(2)", 'M', cigar.getCigarCharOpFromQueryIndex(2));
652 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(3)", 'M', cigar.getCigarCharOpFromQueryIndex(3));
653 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(4)", 'M', cigar.getCigarCharOpFromQueryIndex(4));
654 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(5)", 'M', cigar.getCigarCharOpFromQueryIndex(5));
655 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(6)", 'M', cigar.getCigarCharOpFromQueryIndex(6));
656 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(7)", 'M', cigar.getCigarCharOpFromQueryIndex(7));
657 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(8)", 'I', cigar.getCigarCharOpFromQueryIndex(8));
658 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(9)", 'I', cigar.getCigarCharOpFromQueryIndex(9));
659 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(10)", 'I', cigar.getCigarCharOpFromQueryIndex(10));
660 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(11)", 'M', cigar.getCigarCharOpFromQueryIndex(11));
661 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(12)", 'M', cigar.getCigarCharOpFromQueryIndex(12));
662 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(13)", 'M', cigar.getCigarCharOpFromQueryIndex(13));
663 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(14)", 'M', cigar.getCigarCharOpFromQueryIndex(14));
664 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(15)", 'M', cigar.getCigarCharOpFromQueryIndex(15));
665 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(16)", '?', cigar.getCigarCharOpFromQueryIndex(16));
666 check(failures, ++testNum, "getCigarCharOpFromQueryIndex(17)", '?', cigar.getCigarCharOpFromQueryIndex(17));
667
668 // Test getCigarCharOpFromRefOffset.
669 check(failures, ++testNum, "getCigarCharOpFromRefOffset(-1)", '?', cigar.getCigarCharOpFromRefOffset(-1));
670 check(failures, ++testNum, "getCigarCharOpFromRefOffset(0)", 'M', cigar.getCigarCharOpFromRefOffset(0));
671 check(failures, ++testNum, "getCigarCharOpFromRefOffset(1)", 'M', cigar.getCigarCharOpFromRefOffset(1));
672 check(failures, ++testNum, "getCigarCharOpFromRefOffset(2)", 'M', cigar.getCigarCharOpFromRefOffset(2));
673 check(failures, ++testNum, "getCigarCharOpFromRefOffset(3)", 'M', cigar.getCigarCharOpFromRefOffset(3));
674 check(failures, ++testNum, "getCigarCharOpFromRefOffset(4)", 'N', cigar.getCigarCharOpFromRefOffset(4));
675 check(failures, ++testNum, "getCigarCharOpFromRefOffset(5)", 'N', cigar.getCigarCharOpFromRefOffset(5));
676 check(failures, ++testNum, "getCigarCharOpFromRefOffset(6)", 'N', cigar.getCigarCharOpFromRefOffset(6));
677 check(failures, ++testNum, "getCigarCharOpFromRefOffset(7)", 'N', cigar.getCigarCharOpFromRefOffset(7));
678 check(failures, ++testNum, "getCigarCharOpFromRefOffset(8)", 'N', cigar.getCigarCharOpFromRefOffset(8));
679 check(failures, ++testNum, "getCigarCharOpFromRefOffset(9)", 'N', cigar.getCigarCharOpFromRefOffset(9));
680 check(failures, ++testNum, "getCigarCharOpFromRefOffset(10)", 'N', cigar.getCigarCharOpFromRefOffset(10));
681 check(failures, ++testNum, "getCigarCharOpFromRefOffset(11)", 'N', cigar.getCigarCharOpFromRefOffset(11));
682 check(failures, ++testNum, "getCigarCharOpFromRefOffset(12)", 'N', cigar.getCigarCharOpFromRefOffset(12));
683 check(failures, ++testNum, "getCigarCharOpFromRefOffset(13)", 'N', cigar.getCigarCharOpFromRefOffset(13));
684 check(failures, ++testNum, "getCigarCharOpFromRefOffset(14)", 'M', cigar.getCigarCharOpFromRefOffset(14));
685 check(failures, ++testNum, "getCigarCharOpFromRefOffset(15)", 'M', cigar.getCigarCharOpFromRefOffset(15));
686 check(failures, ++testNum, "getCigarCharOpFromRefOffset(16)", 'M', cigar.getCigarCharOpFromRefOffset(16));
687 check(failures, ++testNum, "getCigarCharOpFromRefOffset(17)", 'M', cigar.getCigarCharOpFromRefOffset(17));
688 check(failures, ++testNum, "getCigarCharOpFromRefOffset(18)", 'M', cigar.getCigarCharOpFromRefOffset(18));
689 check(failures, ++testNum, "getCigarCharOpFromRefOffset(19)", 'M', cigar.getCigarCharOpFromRefOffset(19));
690 check(failures, ++testNum, "getCigarCharOpFromRefOffset(20)", 'D', cigar.getCigarCharOpFromRefOffset(20));
691 check(failures, ++testNum, "getCigarCharOpFromRefOffset(21)", 'D', cigar.getCigarCharOpFromRefOffset(21));
692 check(failures, ++testNum, "getCigarCharOpFromRefOffset(22)", 'D', cigar.getCigarCharOpFromRefOffset(22));
693 check(failures, ++testNum, "getCigarCharOpFromRefOffset(23)", 'D', cigar.getCigarCharOpFromRefOffset(23));
694 check(failures, ++testNum, "getCigarCharOpFromRefOffset(24)", 'M', cigar.getCigarCharOpFromRefOffset(24));
695 check(failures, ++testNum, "getCigarCharOpFromRefOffset(25)", 'M', cigar.getCigarCharOpFromRefOffset(25));
696 check(failures, ++testNum, "getCigarCharOpFromRefOffset(26)", 'M', cigar.getCigarCharOpFromRefOffset(26));
697 check(failures, ++testNum, "getCigarCharOpFromRefOffset(27)", '?', cigar.getCigarCharOpFromRefOffset(27));
698 check(failures, ++testNum, "getCigarCharOpFromRefOffset(28)", '?', cigar.getCigarCharOpFromRefOffset(28));
699 check(failures, ++testNum, "getCigarCharOpFromRefOffset(29)", '?', cigar.getCigarCharOpFromRefOffset(29));
700 check(failures, ++testNum, "getCigarCharOpFromRefOffset(30)", '?', cigar.getCigarCharOpFromRefOffset(30));
701
702
703 // Test getCigarCharOpFromRefPos.
704 check(failures, ++testNum, "getCigarCharOpFromRefPos(-1, 5)", '?', cigar.getCigarCharOpFromRefPos(-1,5));
705 check(failures, ++testNum, "getCigarCharOpFromRefPos(0, 5)", '?', cigar.getCigarCharOpFromRefPos(0,5));
706 check(failures, ++testNum, "getCigarCharOpFromRefPos(1, 5)", '?', cigar.getCigarCharOpFromRefPos(1,5));
707 check(failures, ++testNum, "getCigarCharOpFromRefPos(2, 5)", '?', cigar.getCigarCharOpFromRefPos(2,5));
708 check(failures, ++testNum, "getCigarCharOpFromRefPos(3, 5)", '?', cigar.getCigarCharOpFromRefPos(3,5));
709 check(failures, ++testNum, "getCigarCharOpFromRefPos(4, 5)", '?', cigar.getCigarCharOpFromRefPos(4,5));
710 check(failures, ++testNum, "getCigarCharOpFromRefPos(5, 5)", 'M', cigar.getCigarCharOpFromRefPos(5,5));
711 check(failures, ++testNum, "getCigarCharOpFromRefPos(6, 5)", 'M', cigar.getCigarCharOpFromRefPos(6,5));
712 check(failures, ++testNum, "getCigarCharOpFromRefPos(7, 5)", 'M', cigar.getCigarCharOpFromRefPos(7,5));
713 check(failures, ++testNum, "getCigarCharOpFromRefPos(8, 5)", 'M', cigar.getCigarCharOpFromRefPos(8,5));
714 check(failures, ++testNum, "getCigarCharOpFromRefPos(9, 5)", 'N', cigar.getCigarCharOpFromRefPos(9,5));
715 check(failures, ++testNum, "getCigarCharOpFromRefPos(10, 5)", 'N', cigar.getCigarCharOpFromRefPos(10,5));
716 check(failures, ++testNum, "getCigarCharOpFromRefPos(11, 5)", 'N', cigar.getCigarCharOpFromRefPos(11,5));
717 check(failures, ++testNum, "getCigarCharOpFromRefPos(12, 5)", 'N', cigar.getCigarCharOpFromRefPos(12,5));
718 check(failures, ++testNum, "getCigarCharOpFromRefPos(13, 5)", 'N', cigar.getCigarCharOpFromRefPos(13,5));
719 check(failures, ++testNum, "getCigarCharOpFromRefPos(14, 5)", 'N', cigar.getCigarCharOpFromRefPos(14,5));
720 check(failures, ++testNum, "getCigarCharOpFromRefPos(15, 5)", 'N', cigar.getCigarCharOpFromRefPos(15,5));
721 check(failures, ++testNum, "getCigarCharOpFromRefPos(16, 5)", 'N', cigar.getCigarCharOpFromRefPos(16,5));
722 check(failures, ++testNum, "getCigarCharOpFromRefPos(17, 5)", 'N', cigar.getCigarCharOpFromRefPos(17,5));
723 check(failures, ++testNum, "getCigarCharOpFromRefPos(18, 5)", 'N', cigar.getCigarCharOpFromRefPos(18,5));
724 check(failures, ++testNum, "getCigarCharOpFromRefPos(19, 5)", 'M', cigar.getCigarCharOpFromRefPos(19,5));
725 check(failures, ++testNum, "getCigarCharOpFromRefPos(20, 5)", 'M', cigar.getCigarCharOpFromRefPos(20,5));
726 check(failures, ++testNum, "getCigarCharOpFromRefPos(21, 5)", 'M', cigar.getCigarCharOpFromRefPos(21,5));
727 check(failures, ++testNum, "getCigarCharOpFromRefPos(22, 5)", 'M', cigar.getCigarCharOpFromRefPos(22,5));
728 check(failures, ++testNum, "getCigarCharOpFromRefPos(23, 5)", 'M', cigar.getCigarCharOpFromRefPos(23,5));
729 check(failures, ++testNum, "getCigarCharOpFromRefPos(24, 5)", 'M', cigar.getCigarCharOpFromRefPos(24,5));
730 check(failures, ++testNum, "getCigarCharOpFromRefPos(25, 5)", 'D', cigar.getCigarCharOpFromRefPos(25,5));
731 check(failures, ++testNum, "getCigarCharOpFromRefPos(26, 5)", 'D', cigar.getCigarCharOpFromRefPos(26,5));
732 check(failures, ++testNum, "getCigarCharOpFromRefPos(27, 5)", 'D', cigar.getCigarCharOpFromRefPos(27,5));
733 check(failures, ++testNum, "getCigarCharOpFromRefPos(28, 5)", 'D', cigar.getCigarCharOpFromRefPos(28,5));
734 check(failures, ++testNum, "getCigarCharOpFromRefPos(29, 5)", 'M', cigar.getCigarCharOpFromRefPos(29,5));
735 check(failures, ++testNum, "getCigarCharOpFromRefPos(30, 5)", 'M', cigar.getCigarCharOpFromRefPos(30,5));
736 check(failures, ++testNum, "getCigarCharOpFromRefPos(31, 5)", 'M', cigar.getCigarCharOpFromRefPos(31,5));
737 check(failures, ++testNum, "getCigarCharOpFromRefPos(32, 5)", '?', cigar.getCigarCharOpFromRefPos(32,5));
738 check(failures, ++testNum, "getCigarCharOpFromRefPos(33, 5)", '?', cigar.getCigarCharOpFromRefPos(33,5));
739
740
741
742
743 ////////////////////////
744 // Test getNumOverlaps.
745 check(failures, ++testNum, "getNumOverlaps(5,32,5)", (uint32_t)13, cigar.getNumOverlaps(5,32,5));
746 check(failures, ++testNum, "getNumOverlaps(5,31,5)", (uint32_t)12, cigar.getNumOverlaps(5,31,5));
747 check(failures, ++testNum, "getNumOverlaps(0,100,5)", (uint32_t)13, cigar.getNumOverlaps(0,100,5));
748 check(failures, ++testNum, "getNumOverlaps(-1, -1,5)", (uint32_t)13, cigar.getNumOverlaps(-1, -1,5));
749 check(failures, ++testNum, "getNumOverlaps(-1,10,5)", (uint32_t)4, cigar.getNumOverlaps(-1,10,5));
750 check(failures, ++testNum, "getNumOverlaps(10,-1,5)", (uint32_t)9, cigar.getNumOverlaps(10,-1,5));
751 check(failures, ++testNum, "getNumOverlaps(9,19,5)", (uint32_t)0, cigar.getNumOverlaps(9,19,5));
752 check(failures, ++testNum, "getNumOverlaps(9,20,5)", (uint32_t)1, cigar.getNumOverlaps(9,20,5));
753 check(failures, ++testNum, "getNumOverlaps(9,6,5)", (uint32_t)0, cigar.getNumOverlaps(9,6,5));
754 check(failures, ++testNum, "getNumOverlaps(0,5,5)", (uint32_t)0, cigar.getNumOverlaps(0,5,5));
755 check(failures, ++testNum, "getNumOverlaps(32,40,5)", (uint32_t)0, cigar.getNumOverlaps(32,40,5));
756 check(failures, ++testNum, "getNumOverlaps(0,5,1)", (uint32_t)4, cigar.getNumOverlaps(0,5,1));
757 check(failures, ++testNum, "getNumOverlaps(32,40,32)", (uint32_t)4, cigar.getNumOverlaps(32,40,32));
758
759 // Get Query Index for reference offset 0 - 27
760 // 4M
761 check(failures, ++testNum, "getQueryIndex(0)", 0, cigar.getQueryIndex(0));
762 check(failures, ++testNum, "getQueryIndex(1)", 1, cigar.getQueryIndex(1));
763 check(failures, ++testNum, "getQueryIndex(2)", 2, cigar.getQueryIndex(2));
764 check(failures, ++testNum, "getQueryIndex(3)", 3, cigar.getQueryIndex(3));
765 // 10N
766 check(failures, ++testNum, "getQueryIndex(4)", -1, cigar.getQueryIndex(4));
767 check(failures, ++testNum, "getQueryIndex(5)", -1, cigar.getQueryIndex(5));
768 check(failures, ++testNum, "getQueryIndex(6)", -1, cigar.getQueryIndex(6));
769 check(failures, ++testNum, "getQueryIndex(7)", -1, cigar.getQueryIndex(7));
770 check(failures, ++testNum, "getQueryIndex(8)", -1, cigar.getQueryIndex(8));
771 check(failures, ++testNum, "getQueryIndex(9)", -1, cigar.getQueryIndex(9));
772 check(failures, ++testNum, "getQueryIndex(10)", -1, cigar.getQueryIndex(10));
773 check(failures, ++testNum, "getQueryIndex(11)", -1, cigar.getQueryIndex(11));
774 check(failures, ++testNum, "getQueryIndex(12)", -1, cigar.getQueryIndex(12));
775 check(failures, ++testNum, "getQueryIndex(13)", -1, cigar.getQueryIndex(13));
776 // 4M
777 check(failures, ++testNum, "getQueryIndex(14)", 4, cigar.getQueryIndex(14));
778 check(failures, ++testNum, "getQueryIndex(15)", 5, cigar.getQueryIndex(15));
779 check(failures, ++testNum, "getQueryIndex(16)", 6, cigar.getQueryIndex(16));
780 check(failures, ++testNum, "getQueryIndex(17)", 7, cigar.getQueryIndex(17));
781 // 3I - nothing to check - not in reference - covers query indices 8-10
782 // 2M
783 check(failures, ++testNum, "getQueryIndex(18)", 11, cigar.getQueryIndex(18));
784 check(failures, ++testNum, "getQueryIndex(19)", 12, cigar.getQueryIndex(19));
785 // 4D
786 check(failures, ++testNum, "getQueryIndex(20)", -1, cigar.getQueryIndex(20));
787 check(failures, ++testNum, "getQueryIndex(21)", -1, cigar.getQueryIndex(21));
788 check(failures, ++testNum, "getQueryIndex(22)", -1, cigar.getQueryIndex(22));
789 check(failures, ++testNum, "getQueryIndex(23)", -1, cigar.getQueryIndex(23));
790 // 3M
791 check(failures, ++testNum, "getQueryIndex(24)", 13, cigar.getQueryIndex(24));
792 check(failures, ++testNum, "getQueryIndex(25)", 14, cigar.getQueryIndex(25));
793 check(failures, ++testNum, "getQueryIndex(26)", 15, cigar.getQueryIndex(26));
794
795 // Get Query Index for reference positions 0-33
796 // N/A
797 check(failures, ++testNum, "getQueryIndex(0, 5)", -1, cigar.getQueryIndex(0, 5));
798 check(failures, ++testNum, "getQueryIndex(1, 5)", -1, cigar.getQueryIndex(1, 5));
799 check(failures, ++testNum, "getQueryIndex(2, 5)", -1, cigar.getQueryIndex(2, 5));
800 check(failures, ++testNum, "getQueryIndex(3, 5)", -1, cigar.getQueryIndex(3, 5));
801 check(failures, ++testNum, "getQueryIndex(4, 5)", -1, cigar.getQueryIndex(4, 5));
802 // 4M
803 check(failures, ++testNum, "getQueryIndex(5, 5)", 0, cigar.getQueryIndex(5, 5));
804 check(failures, ++testNum, "getQueryIndex(6, 5)", 1, cigar.getQueryIndex(6, 5));
805 check(failures, ++testNum, "getQueryIndex(7, 5)", 2, cigar.getQueryIndex(7, 5));
806 check(failures, ++testNum, "getQueryIndex(8, 5)", 3, cigar.getQueryIndex(8, 5));
807 // 10N
808 check(failures, ++testNum, "getQueryIndex(9, 5)", -1, cigar.getQueryIndex(9, 5));
809 check(failures, ++testNum, "getQueryIndex(10, 5)", -1, cigar.getQueryIndex(10, 5));
810 check(failures, ++testNum, "getQueryIndex(11, 5)", -1, cigar.getQueryIndex(11, 5));
811 check(failures, ++testNum, "getQueryIndex(12, 5)", -1, cigar.getQueryIndex(12, 5));
812 check(failures, ++testNum, "getQueryIndex(13, 5)", -1, cigar.getQueryIndex(13, 5));
813 check(failures, ++testNum, "getQueryIndex(14, 5)", -1, cigar.getQueryIndex(14, 5));
814 check(failures, ++testNum, "getQueryIndex(15, 5)", -1, cigar.getQueryIndex(15, 5));
815 check(failures, ++testNum, "getQueryIndex(16, 5)", -1, cigar.getQueryIndex(16, 5));
816 check(failures, ++testNum, "getQueryIndex(17, 5)", -1, cigar.getQueryIndex(17, 5));
817 check(failures, ++testNum, "getQueryIndex(18, 5)", -1, cigar.getQueryIndex(18, 5));
818 // 4M
819 check(failures, ++testNum, "getQueryIndex(19, 5)", 4, cigar.getQueryIndex(19, 5));
820 check(failures, ++testNum, "getQueryIndex(20, 5)", 5, cigar.getQueryIndex(20, 5));
821 check(failures, ++testNum, "getQueryIndex(21, 5)", 6, cigar.getQueryIndex(21, 5));
822 check(failures, ++testNum, "getQueryIndex(22, 5)", 7, cigar.getQueryIndex(22, 5));
823 // 3I - nothing to check - not in reference - covers query indices 8-10
824 // 2M
825 check(failures, ++testNum, "getQueryIndex(23, 5)", 11, cigar.getQueryIndex(23, 5));
826 check(failures, ++testNum, "getQueryIndex(24, 5)", 12, cigar.getQueryIndex(24, 5));
827 // 4D
828 check(failures, ++testNum, "getQueryIndex(25, 5)", -1, cigar.getQueryIndex(25, 5));
829 check(failures, ++testNum, "getQueryIndex(26, 5)", -1, cigar.getQueryIndex(26, 5));
830 check(failures, ++testNum, "getQueryIndex(27, 5)", -1, cigar.getQueryIndex(27, 5));
831 check(failures, ++testNum, "getQueryIndex(28, 5)", -1, cigar.getQueryIndex(28, 5));
832 // 3M
833 check(failures, ++testNum, "getQueryIndex(29, 5)", 13, cigar.getQueryIndex(29, 5));
834 check(failures, ++testNum, "getQueryIndex(30, 5)", 14, cigar.getQueryIndex(30, 5));
835 check(failures, ++testNum, "getQueryIndex(31, 5)", 15, cigar.getQueryIndex(31, 5));
836
837 // Get reference offset for query index 0 - 17
838 // 4M
839 check(failures, ++testNum, "getRefOffset(0)", 0, cigar.getRefOffset(0));
840 check(failures, ++testNum, "getRefOffset(1)", 1, cigar.getRefOffset(1));
841 check(failures, ++testNum, "getRefOffset(2)", 2, cigar.getRefOffset(2));
842 check(failures, ++testNum, "getRefOffset(3)", 3, cigar.getRefOffset(3));
843 // 10N - nothing to check - not in query - covers ref offsets 4-13
844 // 4M
845 check(failures, ++testNum, "getRefOffset(4)", 14, cigar.getRefOffset(4));
846 check(failures, ++testNum, "getRefOffset(5)", 15, cigar.getRefOffset(5));
847 check(failures, ++testNum, "getRefOffset(6)", 16, cigar.getRefOffset(6));
848 check(failures, ++testNum, "getRefOffset(7)", 17, cigar.getRefOffset(7));
849 // 3I
850 check(failures, ++testNum, "getRefOffset(8)", -1, cigar.getRefOffset(8));
851 check(failures, ++testNum, "getRefOffset(9)", -1, cigar.getRefOffset(9));
852 check(failures, ++testNum, "getRefOffset(10)", -1, cigar.getRefOffset(10));
853 // 2M
854 check(failures, ++testNum, "getRefOffset(11)", 18, cigar.getRefOffset(11));
855 check(failures, ++testNum, "getRefOffset(12)", 19, cigar.getRefOffset(12));
856 // 4D - nothing to check - not in query - covers ref offsets 20-23
857 // 3M
858 check(failures, ++testNum, "getRefOffset(13)", 24, cigar.getRefOffset(13));
859 check(failures, ++testNum, "getRefOffset(14)", 25, cigar.getRefOffset(14));
860 check(failures, ++testNum, "getRefOffset(15)", 26, cigar.getRefOffset(15));
861
862
863 // Get reference position for query index 0 - 17
864 // 4M
865 check(failures, ++testNum, "getRefPosition(0, 5)", 5, cigar.getRefPosition(0, 5));
866 check(failures, ++testNum, "getRefPosition(1, 5)", 6, cigar.getRefPosition(1, 5));
867 check(failures, ++testNum, "getRefPosition(2, 5)", 7, cigar.getRefPosition(2, 5));
868 check(failures, ++testNum, "getRefPosition(3, 5)", 8, cigar.getRefPosition(3, 5));
869 // 10N - nothing to check - not in query - covers ref offsets 4-13
870 // 4M
871 check(failures, ++testNum, "getRefPosition(4, 5)", 19, cigar.getRefPosition(4, 5));
872 check(failures, ++testNum, "getRefPosition(5, 5)", 20, cigar.getRefPosition(5, 5));
873 check(failures, ++testNum, "getRefPosition(6, 5)", 21, cigar.getRefPosition(6, 5));
874 check(failures, ++testNum, "getRefPosition(7, 5)", 22, cigar.getRefPosition(7, 5));
875 // 3I
876 check(failures, ++testNum, "getRefPosition(8, 5)", -1, cigar.getRefPosition(8, 5));
877 check(failures, ++testNum, "getRefPosition(9, 5)", -1, cigar.getRefPosition(9, 5));
878 check(failures, ++testNum, "getRefPosition(10, 5)", -1, cigar.getRefPosition(10, 5));
879 // 2M
880 check(failures, ++testNum, "getRefPosition(11, 5)", 23, cigar.getRefPosition(11, 5));
881 check(failures, ++testNum, "getRefPosition(12, 5)", 24, cigar.getRefPosition(12, 5));
882 // 4D - nothing to check - not in query - covers ref pos 25-28
883 // 3M
884 check(failures, ++testNum, "getRefPosition(13, 5)", 29, cigar.getRefPosition(13, 5));
885 check(failures, ++testNum, "getRefPosition(14, 5)", 30, cigar.getRefPosition(14, 5));
886 check(failures, ++testNum, "getRefPosition(15, 5)", 31, cigar.getRefPosition(15, 5));
887
888
889
890 ////////////////////////////////////////////////////////////////////////////
891 // Test a new CIGAR set by buffer.
892 // 2S 3M 1I 2M 1D 1M 2P 1M 3N 1M 3H
893 uint32_t cigarBuf[] = {0x24, // 2S = 2 << 4 | 4
894 0x30, // 3M = 3 << 4 | 0
895 0x11, // 1I = 1 << 4 | 1
896 0x20, // 2M = 2 << 4 | 0
897 0x12, // 1D = 1 << 4 | 2
898 0x10, // 1M = 1 << 4 | 0
899 0x26, // 2P = 2 << 4 | 6
900 0x10, // 1m = 1 << 4 | 0
901 0x33, // 3N = 3 << 4 | 3
902 0x10, // 1M = 1 << 4 | 0
903 0x35}; // 3H = 3 << 4 | 5
904 cigar.Set(cigarBuf, 11);
905 cigarString = "HI";
906 cigar.getCigarString(cigarString);
907 expectedResult = "2S3M1I2M1D1M2P1M3N1M3H";
908 check(failures, ++testNum, "getCigarString", expectedResult, cigarString);
909 check(failures, ++testNum, "getNumEndClips", 3, cigar.getNumEndClips());
910 check(failures, ++testNum, "getNumBeginClips", 2, cigar.getNumBeginClips());
911
912 std::cout << "\nCigarRoller PASS: " << testNum - failures << " FAIL: " << failures << std::endl;
913 // return the number of failures.
914 return(failures);
915}
916
917
918int main(int argc, const char **argv)
919{
920 CigarRollerTest roller;
921
922 bool showAllCasesFlag = false;
923 int opt;
924
925 while(( opt = getopt(argc, (char **) argv, "v")) != -1) {
926 switch(opt) {
927 case 'v':
928 showAllCasesFlag = true;
929 break;
930 default:
931 std::cerr << "usage: testSW [-v]" << std::endl;
932 exit(1);
933 }
934 }
935 if(showAllCasesFlag)
936 {
937 }
938
939 //
940 // do cigar roller tests first
941 //
942 return(roller.test());
943
944 // CIGAR explanation - for backward SW runs, the corresponding
945 // CIGAR string is generated from the back of the string to the
946 // front. Recall that the soft clipping is only done at the
947 // "end" of the string, taking direction into account.
948
949 // Comment out this result since it doesn't refelct the results of test.
950 // cout << endl << "Total Errors found: " << errors << endl;
951}
The purpose of this class is to provide accessors for setting, updating, modifying the CIGAR object....
Definition: CigarRoller.h:67
void Set(const char *cigarString)
Sets this object to the specified cigarString.
int size() const
Return the number of cigar operations.
Definition: Cigar.h:364
static const int32_t INDEX_NA
Value associated with an index that is not applicable/does not exist, used for converting between que...
Definition: Cigar.h:492
char getCigarCharOp(int32_t expandedCigarIndex)
Return the character code of the cigar operator associated with the specified expanded CIGAR index.
Definition: Cigar.cpp:295
static bool foundInReference(Operation op)
Return true if the specified operation is found in the reference sequence, false if not.
Definition: Cigar.h:177
char getCigarCharOpFromQueryIndex(int32_t queryIndex)
Return the character code of the cigar operator associated with the specified queryIndex.
Definition: Cigar.cpp:314
int32_t getExpandedCigarIndexFromQueryIndex(int32_t queryIndex)
Returns the index into the expanded cigar for the cigar associated with the specified queryIndex.
Definition: Cigar.cpp:258
static bool foundInQuery(Operation op)
Return true if the specified operation is found in the query sequence, false if not.
Definition: Cigar.h:219
int32_t getExpandedCigarIndexFromRefPos(int32_t refPosition, int32_t queryStartPos)
Returns the index into the expanded cigar for the cigar associated with the specified reference posit...
Definition: Cigar.cpp:288
int getNumBeginClips() const
Return the number of clips that are at the beginning of the cigar.
Definition: Cigar.cpp:144
int getNumEndClips() const
Return the number of clips that are at the end of the cigar.
Definition: Cigar.cpp:166
char getCigarCharOpFromRefOffset(int32_t refOffset)
Return the character code of the cigar operator associated with the specified reference offset.
Definition: Cigar.cpp:320
int32_t getRefPosition(int32_t queryIndex, int32_t queryStartPos)
Return the reference position associated with the specified query index or INDEX_NA based on this cig...
Definition: Cigar.cpp:217
int32_t getExpandedCigarIndexFromRefOffset(int32_t refOffset)
Returns the index into the expanded cigar for the cigar associated with the specified reference offse...
Definition: Cigar.cpp:273
@ del
deletion from the reference (the reference contains bases that have no corresponding base in the quer...
Definition: Cigar.h:92
@ mismatch
mismatch operation. Associated with CIGAR Operation "M"
Definition: Cigar.h:90
@ hardClip
Hard clip on the read (clipped sequence not present in the query sequence or reference)....
Definition: Cigar.h:95
@ match
match/mismatch operation. Associated with CIGAR Operation "M"
Definition: Cigar.h:89
@ pad
Padding (not in reference or query). Associated with CIGAR Operation "P".
Definition: Cigar.h:96
@ insert
insertion to the reference (the query sequence contains bases that have no corresponding base in the ...
Definition: Cigar.h:91
@ skip
skipped region from the reference (the reference contains bases that have no corresponding base in th...
Definition: Cigar.h:93
@ softClip
Soft clip on the read (clipped sequence present in the query sequence, but not in reference)....
Definition: Cigar.h:94
@ none
no operation has been set.
Definition: Cigar.h:88
int32_t getRefOffset(int32_t queryIndex)
Return the reference offset associated with the specified query index or INDEX_NA based on this cigar...
Definition: Cigar.cpp:187
uint32_t getNumOverlaps(int32_t start, int32_t end, int32_t queryStartPos)
Return the number of bases that overlap the reference and the read associated with this cigar that fa...
Definition: Cigar.cpp:334
char getCigarCharOpFromRefPos(int32_t refPosition, int32_t queryStartPos)
Return the character code of the cigar operator associated with the specified reference position.
Definition: Cigar.cpp:326
void getCigarString(String &cigarString) const
Set the passed in String to the string reprentation of the Cigar operations in this object.
Definition: Cigar.cpp:52
int32_t getQueryIndex(int32_t refOffset)
Return the query index associated with the specified reference offset or INDEX_NA based on this cigar...
Definition: Cigar.cpp:202
static bool isClip(Operation op)
Return true if the specified operation is a clipping operation, false if not.
Definition: Cigar.h:261