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 //
32 int 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,
158  Cigar::foundInQuery(op));
159  op.operation = Cigar::match;
160  check(failures, ++testNum, "foundInQuery(match)", true,
161  Cigar::foundInQuery(op));
162  op.operation = Cigar::mismatch;
163  check(failures, ++testNum, "foundInQuery(mismatch)", true,
164  Cigar::foundInQuery(op));
165  op.operation = Cigar::insert;
166  check(failures, ++testNum, "foundInQuery(insert)", true,
167  Cigar::foundInQuery(op));
168  op.operation = Cigar::del;
169  check(failures, ++testNum, "foundInQuery(del)", false,
170  Cigar::foundInQuery(op));
171  op.operation = Cigar::skip;
172  check(failures, ++testNum, "foundInQuery(skip)", false,
173  Cigar::foundInQuery(op));
174  op.operation = Cigar::softClip;
175  check(failures, ++testNum, "foundInQuery(softClip)", true,
176  Cigar::foundInQuery(op));
177  op.operation = Cigar::hardClip;
178  check(failures, ++testNum, "foundInQuery(hardClip)", false,
179  Cigar::foundInQuery(op));
180  op.operation = Cigar::pad;
181  check(failures, ++testNum, "foundInQuery(pad)", false,
182  Cigar::foundInQuery(op));
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 
918 int 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 }
Cigar::CigarOperator
Definition: Cigar.h:107
Cigar::isClip
static bool isClip(Operation op)
Return true if the specified operation is a clipping operation, false if not.
Definition: Cigar.h:261
Cigar::getExpandedCigarIndexFromRefOffset
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
CigarRoller::Set
void Set(const char *cigarString)
Sets this object to the specified cigarString.
Definition: CigarRoller.cpp:204
String
Definition: StringBasics.h:38
Cigar::pad
@ pad
Padding (not in reference or query). Associated with CIGAR Operation "P".
Definition: Cigar.h:96
Cigar::none
@ none
no operation has been set.
Definition: Cigar.h:88
Cigar::insert
@ insert
insertion to the reference (the query sequence contains bases that have no corresponding base in the ...
Definition: Cigar.h:91
Cigar::getNumEndClips
int getNumEndClips() const
Return the number of clips that are at the end of the cigar.
Definition: Cigar.cpp:166
Cigar::hardClip
@ hardClip
Hard clip on the read (clipped sequence not present in the query sequence or reference)....
Definition: Cigar.h:95
CigarRollerTest
Definition: CigarRollerTest.h:20
Cigar::getCigarString
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
Cigar::INDEX_NA
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
Cigar::foundInReference
static bool foundInReference(Operation op)
Return true if the specified operation is found in the reference sequence, false if not.
Definition: Cigar.h:177
Cigar::match
@ match
match/mismatch operation. Associated with CIGAR Operation "M"
Definition: Cigar.h:89
Cigar::skip
@ skip
skipped region from the reference (the reference contains bases that have no corresponding base in th...
Definition: Cigar.h:93
Cigar::softClip
@ softClip
Soft clip on the read (clipped sequence present in the query sequence, but not in reference)....
Definition: Cigar.h:94
Cigar::getCigarCharOp
char getCigarCharOp(int32_t expandedCigarIndex)
Return the character code of the cigar operator associated with the specified expanded CIGAR index.
Definition: Cigar.cpp:295
Cigar::foundInQuery
static bool foundInQuery(Operation op)
Return true if the specified operation is found in the query sequence, false if not.
Definition: Cigar.h:219
Cigar::size
int size() const
Return the number of cigar operations.
Definition: Cigar.h:364
Cigar::getNumBeginClips
int getNumBeginClips() const
Return the number of clips that are at the beginning of the cigar.
Definition: Cigar.cpp:144
Cigar::getNumOverlaps
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
Cigar::mismatch
@ mismatch
mismatch operation. Associated with CIGAR Operation "M"
Definition: Cigar.h:90
Cigar::getCigarCharOpFromRefPos
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
Cigar::getQueryIndex
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
Cigar::del
@ del
deletion from the reference (the reference contains bases that have no corresponding base in the quer...
Definition: Cigar.h:92
Cigar::getExpandedCigarIndexFromRefPos
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
Cigar::getRefOffset
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
CigarRoller
The purpose of this class is to provide accessors for setting, updating, modifying the CIGAR object....
Definition: CigarRoller.h:66
Cigar::getCigarCharOpFromQueryIndex
char getCigarCharOpFromQueryIndex(int32_t queryIndex)
Return the character code of the cigar operator associated with the specified queryIndex.
Definition: Cigar.cpp:314
Cigar::getCigarCharOpFromRefOffset
char getCigarCharOpFromRefOffset(int32_t refOffset)
Return the character code of the cigar operator associated with the specified reference offset.
Definition: Cigar.cpp:320
Cigar::getExpandedCigarIndexFromQueryIndex
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
Cigar::getRefPosition
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