libStatGen Software 1
TestValidate.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#include "TestValidate.h"
19#include "BaseUtilities.h"
20
21const std::string TestValidate::READ1_CIGAR = "5M2D";
22const std::string TestValidate::READ1_SEQ = "CCGAA";
23const std::string TestValidate::READ1_QUAL = "6>6+4";
24
25const std::string TestValidate::READ6_CIGAR = "3S2H5M";
26const std::string TestValidate::READ6_SEQ = "TGCACGTN";
27const std::string TestValidate::READ6_QUAL = "453;>>>>";
28
29const std::string TestValidate::READ7_CIGAR = "3S5M1S3H";
30const std::string TestValidate::READ7_SEQ = "TGCACGTNG";
31const std::string TestValidate::READ7_QUAL = "453;>>>>5";
32
33void validateRead1(SamRecord& samRecord)
34{
35 //////////////////////////////////////////
36 // Validate Record 1
37 // Create record structure for validating.
38 int expectedBlockSize = 89;
39 const char* expectedReferenceName = "1";
40 const char* expectedMateReferenceName = "1";
41 const char* expectedMateReferenceNameOrEqual = "=";
42
43 bamRecordStruct* expectedRecordPtr =
44 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
45
46 char tag[3];
47 char type;
48 void* value;
49 const bamRecordStruct* bufferPtr;
50 unsigned char* varPtr;
51
52 expectedRecordPtr->myBlockSize = expectedBlockSize;
53 expectedRecordPtr->myReferenceID = 0;
54 expectedRecordPtr->myPosition = TestValidate::READ1_POS;
55 expectedRecordPtr->myReadNameLength = 23;
56 expectedRecordPtr->myMapQuality = 0;
57 expectedRecordPtr->myBin = 4681;
58 expectedRecordPtr->myCigarLength = 2;
59 expectedRecordPtr->myFlag = 73;
60 expectedRecordPtr->myReadLength = 5;
61 expectedRecordPtr->myMateReferenceID = 0;
62 expectedRecordPtr->myMatePosition = 1010;
63 expectedRecordPtr->myInsertSize = 0;
64
65 assert(samRecord.getString("MD") == "37");
66 assert(samRecord.getString("YZ") == "");
67 assert(samRecord.getInteger("YZ") == -1);
68 float tmpFloat = -1;
69 assert(samRecord.getFloatTag("YZ", tmpFloat) == false);
70 // Check the alignment end
71 assert(samRecord.get0BasedAlignmentEnd() == TestValidate::READ1_ALIGN_END);
72 assert(samRecord.get1BasedAlignmentEnd() == (TestValidate::READ1_ALIGN_END + 1));
73 assert(samRecord.getAlignmentLength() == TestValidate::READ1_ALIGN_LEN);
74 assert(samRecord.get1BasedUnclippedStart() == (TestValidate::READ1_UNCLIP_START + 1));
75 assert(samRecord.get0BasedUnclippedStart() == TestValidate::READ1_UNCLIP_START);
76 assert(samRecord.get1BasedUnclippedEnd() == (TestValidate::READ1_UNCLIP_END + 1));
77 assert(samRecord.get0BasedUnclippedEnd() == TestValidate::READ1_UNCLIP_END);
78
79 // Check the accessors.
80 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
81 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
82 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
83 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
84 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
85 assert(samRecord.getReadNameLength() ==
86 expectedRecordPtr->myReadNameLength);
87 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
88 assert(samRecord.getBin() == expectedRecordPtr->myBin);
89 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
90 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
91 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
92 assert(samRecord.getMateReferenceID() ==
93 expectedRecordPtr->myMateReferenceID);
94 assert(strcmp(samRecord.getMateReferenceName(),
95 expectedMateReferenceName) == 0);
96 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
97 expectedMateReferenceNameOrEqual) == 0);
98 assert(samRecord.get1BasedMatePosition() ==
99 expectedRecordPtr->myMatePosition + 1);
100 assert(samRecord.get0BasedMatePosition() ==
101 expectedRecordPtr->myMatePosition);
102 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
103 assert(strcmp(samRecord.getReadName(), "1:1011:F:255+17M15D20M") == 0);
104 assert(samRecord.getCigar() == TestValidate::READ1_CIGAR);
105 assert(samRecord.getSequence() == TestValidate::READ1_SEQ);
106 assert(samRecord.getQuality() == TestValidate::READ1_QUAL);
107
108 assert(samRecord.getSequence(0) == 'C');
109 assert(samRecord.getQuality(0) == '6');
110 assert(samRecord.getSequence(1) == 'C');
111 assert(samRecord.getQuality(1) == '>');
112 assert(samRecord.getSequence(2) == 'G');
113 assert(samRecord.getQuality(2) == '6');
114 assert(samRecord.getSequence(3) == 'A');
115 assert(samRecord.getQuality(3) == '+');
116 assert(samRecord.getSequence(4) == 'A');
117 assert(samRecord.getQuality(4) == '4');
118
119 bool caught = false;
120 try
121 {
122 samRecord.getSequence(-1);
123 }
124 catch (std::exception& e)
125 {
126 caught = true;
127 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is out of range. Index must be between 0 and 4") == 0);
128 }
129 assert(caught == true);
130 caught = false;
131 try
132 {
133 samRecord.getQuality(-1);
134 }
135 catch (std::exception& e)
136 {
137 caught = true;
138 assert(strcmp(e.what(), "SamRecord::getQuality(-1) is out of range. Index must be between 0 and 4") == 0);
139 }
140 assert(caught == true);
141
142 caught = false;
143 try
144 {
145 samRecord.getSequence(5);
146 }
147 catch (std::exception& e)
148 {
149 caught = true;
150 assert(strcmp(e.what(), "SamRecord::getSequence(5) is out of range. Index must be between 0 and 4") == 0);
151 }
152 assert(caught == true);
153 caught = false;
154 try
155 {
156 samRecord.getQuality(5);
157 }
158 catch (std::exception& e)
159 {
160 caught = true;
161 assert(strcmp(e.what(), "SamRecord::getQuality(5) is out of range. Index must be between 0 and 4") == 0);
162 }
163 assert(caught == true);
164
165 assert(samRecord.getNumOverlaps(1010, 1017) == 5);
166 assert(samRecord.getNumOverlaps(1010, 1016) == 5);
167 assert(samRecord.getNumOverlaps(1012, 1017) == 3);
168 assert(samRecord.getNumOverlaps(1015, 1017) == 0);
169 assert(samRecord.getNumOverlaps(1017, 1010) == 0);
170 assert(samRecord.getNumOverlaps(1013, 1011) == 0);
171 assert(samRecord.getNumOverlaps(-1, 1017) == 5);
172 assert(samRecord.getNumOverlaps(1010, -1) == 5);
173
174 // Check the tags.
175 assert(samRecord.getNextSamTag(tag, type, &value) == true);
176 assert(tag[0] == 'A');
177 assert(tag[1] == 'M');
178 assert(type == 'i');
179 assert(*(char*)value == 0);
180 assert(samRecord.getNextSamTag(tag, type, &value) == true);
181 assert(tag[0] == 'M');
182 assert(tag[1] == 'D');
183 assert(type == 'Z');
184 assert(*(String*)value == "37");
185 assert(samRecord.getNextSamTag(tag, type, &value) == true);
186 assert(tag[0] == 'N');
187 assert(tag[1] == 'M');
188 assert(type == 'i');
189 assert(*(char*)value == 0);
190 assert(samRecord.getNextSamTag(tag, type, &value) == true);
191 assert(tag[0] == 'X');
192 assert(tag[1] == 'T');
193 assert(type == 'A');
194 assert(*(char*)value == 'R');
195 // No more tags, should return false.
196 assert(samRecord.getNextSamTag(tag, type, &value) == false);
197 assert(samRecord.getNextSamTag(tag, type, &value) == false);
198
199 // Get the record ptr.
200 bufferPtr = (const bamRecordStruct*)samRecord.getRecordBuffer();
201 // Validate the buffers match.
202 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
203 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
204 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
205 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
206 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
207 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
208 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
209 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
210 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
211 assert(bufferPtr->myMateReferenceID ==
212 expectedRecordPtr->myMateReferenceID);
213 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
214 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
215
216 // Validate the variable length fields in the buffer.
217 // Set the pointer to the start of the variable fields.
218 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
219
220 // Validate the readname.
221 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
222 {
223 assert(*varPtr == samRecord.getReadName()[i]);
224 varPtr++;
225 }
226
227 // Validate the cigar.
228 // The First cigar is 5M which is 5 << 4 | 0 = 80
229 assert(*(unsigned int*)varPtr == 80);
230 // Increment the varptr the size of an int.
231 varPtr += 4;
232 // The 2nd cigar is 2D which is 2 << 4 | 2 = 34
233 assert(*(unsigned int*)varPtr == 34);
234 // Increment the varptr the size of an int.
235 varPtr += 4;
236
237 // Validate the sequence.
238 // CC = 0x22
239 assert(*varPtr == 0x22);
240 varPtr++;
241 // GA = 0x41
242 assert(*varPtr == 0x41);
243 varPtr++;
244 // A = 0x10
245 assert(*varPtr == 0x10);
246 varPtr++;
247
248 // Validate the Quality
249 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
250 {
251 assert(*varPtr == samRecord.getQuality()[i] - 33);
252 varPtr++;
253 }
254
255 // Validate the tags.
256 assert(*varPtr == 'A');
257 varPtr++;
258 assert(*varPtr == 'M');
259 varPtr++;
260 assert(*varPtr == 'C');
261 varPtr++;
262 assert(*varPtr == 0);
263 varPtr++;
264 assert(*varPtr == 'M');
265 varPtr++;
266 assert(*varPtr == 'D');
267 varPtr++;
268 assert(*varPtr == 'Z');
269 varPtr++;
270 assert(*varPtr == '3');
271 varPtr++;
272 assert(*varPtr == '7');
273 varPtr++;
274 assert(*varPtr == 0);
275 varPtr++;
276 assert(*varPtr == 'N');
277 varPtr++;
278 assert(*varPtr == 'M');
279 varPtr++;
280 assert(*varPtr == 'C');
281 varPtr++;
282 assert(*varPtr == 0);
283 varPtr++;
284 assert(*varPtr == 'X');
285 varPtr++;
286 assert(*varPtr == 'T');
287 varPtr++;
288 assert(*varPtr == 'A');
289 varPtr++;
290 assert(*varPtr == 'R');
291 varPtr++;
292}
293
294
295void validateRead2(SamRecord& samRecord)
296{
297 //////////////////////////////////////////
298 // Validate Record 2
299 // Create record structure for validating.
300 int expectedBlockSize = 61;
301 const char* expectedReferenceName = "1";
302 const char* expectedMateReferenceName = "1";
303 const char* expectedMateReferenceNameOrEqual = "=";
304
305 bamRecordStruct* expectedRecordPtr =
306 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
307
308 char tag[3];
309 char type;
310 void* value;
311 bamRecordStruct* bufferPtr;
312 unsigned char* varPtr;
313
314 expectedRecordPtr->myBlockSize = expectedBlockSize;
315 expectedRecordPtr->myReferenceID = 0;
316 expectedRecordPtr->myPosition = TestValidate::READ2_POS;
317 expectedRecordPtr->myReadNameLength = 23;
318 expectedRecordPtr->myMapQuality = 0;
319 expectedRecordPtr->myBin = 4681;
320 expectedRecordPtr->myCigarLength = 0;
321 expectedRecordPtr->myFlag = 133;
322 expectedRecordPtr->myReadLength = 4;
323 expectedRecordPtr->myMateReferenceID = 0;
324 expectedRecordPtr->myMatePosition = 1010;
325 expectedRecordPtr->myInsertSize = 0;
326
327 // Check the fields.
328 bamRecordStruct retrieveRecord;
329 String retrieveReadName;
330 String retrieveCigar;
331 String retrieveSequence;
332 String retrieveQuality;
333
334 assert(samRecord.getFields(retrieveRecord, retrieveReadName,
335 retrieveCigar, retrieveSequence,
336 retrieveQuality) == true);
337 assert(retrieveRecord.myBlockSize == expectedRecordPtr->myBlockSize);
338 assert(retrieveRecord.myReferenceID == expectedRecordPtr->myReferenceID);
339 assert(retrieveRecord.myPosition == expectedRecordPtr->myPosition);
340 assert(retrieveRecord.myReadNameLength ==
341 expectedRecordPtr->myReadNameLength);
342 assert(retrieveRecord.myMapQuality == expectedRecordPtr->myMapQuality);
343 assert(retrieveRecord.myBin == expectedRecordPtr->myBin);
344 assert(retrieveRecord.myCigarLength == expectedRecordPtr->myCigarLength);
345 assert(retrieveRecord.myFlag == expectedRecordPtr->myFlag);
346 assert(retrieveRecord.myReadLength == expectedRecordPtr->myReadLength);
347 assert(retrieveRecord.myMateReferenceID ==
348 expectedRecordPtr->myMateReferenceID);
349 assert(retrieveRecord.myMatePosition == expectedRecordPtr->myMatePosition);
350 assert(retrieveRecord.myInsertSize == expectedRecordPtr->myInsertSize);
351
352 // Check the alignment end
353 assert(samRecord.getAlignmentLength() == 0);
354 assert(samRecord.get0BasedAlignmentEnd() == 1011);
355 assert(samRecord.get1BasedAlignmentEnd() == 1012);
356 assert(samRecord.get0BasedUnclippedStart() == 1011);
357 assert(samRecord.get1BasedUnclippedStart() == 1012);
358 assert(samRecord.get0BasedUnclippedEnd() == 1011);
359 assert(samRecord.get1BasedUnclippedEnd() == 1012);
360
361 // Check the accessors.
362 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
363 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
364 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
365 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
366 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
367 assert(samRecord.getReadNameLength() ==
368 expectedRecordPtr->myReadNameLength);
369 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
370 assert(samRecord.getBin() == expectedRecordPtr->myBin);
371 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
372 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
373 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
374 assert(samRecord.getMateReferenceID() ==
375 expectedRecordPtr->myMateReferenceID);
376 assert(strcmp(samRecord.getMateReferenceName(),
377 expectedMateReferenceName) == 0);
378 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
379 expectedMateReferenceNameOrEqual) == 0);
380 assert(samRecord.get1BasedMatePosition() ==
381 expectedRecordPtr->myMatePosition + 1);
382 assert(samRecord.get0BasedMatePosition() ==
383 expectedRecordPtr->myMatePosition);
384 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
385 assert(strcmp(samRecord.getReadName(), "1:1011:F:255+17M15D20M") == 0);
386 assert(strcmp(samRecord.getCigar(), "*") == 0);
387 assert(strcmp(samRecord.getSequence(), "CTGT") == 0);
388 assert(strcmp(samRecord.getQuality(), ">>9>") == 0);
389
390 assert(samRecord.getSequence(0) == 'C');
391 assert(samRecord.getQuality(0) == '>');
392 assert(samRecord.getSequence(1) == 'T');
393 assert(samRecord.getQuality(1) == '>');
394 assert(samRecord.getSequence(2) == 'G');
395 assert(samRecord.getQuality(2) == '9');
396 assert(samRecord.getSequence(3) == 'T');
397 assert(samRecord.getQuality(3) == '>');
398 bool caught = false;
399 try
400 {
401 samRecord.getSequence(-1);
402 }
403 catch (std::exception& e)
404 {
405 caught = true;
406 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is out of range. Index must be between 0 and 3") == 0);
407 }
408 assert(caught == true);
409 caught = false;
410 try
411 {
412 samRecord.getQuality(-1);
413 }
414 catch (std::exception& e)
415 {
416 caught = true;
417 assert(strcmp(e.what(), "SamRecord::getQuality(-1) is out of range. Index must be between 0 and 3") == 0);
418 }
419 assert(caught == true);
420
421 caught = false;
422 try
423 {
424 samRecord.getSequence(4);
425 }
426 catch (std::exception& e)
427 {
428 caught = true;
429 assert(strcmp(e.what(), "SamRecord::getSequence(4) is out of range. Index must be between 0 and 3") == 0);
430 }
431 assert(caught == true);
432 caught = false;
433 try
434 {
435 samRecord.getQuality(4);
436 }
437 catch (std::exception& e)
438 {
439 caught = true;
440 assert(strcmp(e.what(), "SamRecord::getQuality(4) is out of range. Index must be between 0 and 3") == 0);
441 }
442 assert(caught == true);
443
444 assert(samRecord.getNumOverlaps(1011, 1017) == 0);
445 assert(samRecord.getNumOverlaps(0, 1116) == 0);
446
447 // No Tags to check, should return false.
448 assert(samRecord.getNextSamTag(tag, type, &value) == false);
449 assert(samRecord.getNextSamTag(tag, type, &value) == false);
450
451 // Get the record ptr.
452 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
453 // Validate the buffers match.
454 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
455 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
456 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
457 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
458 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
459 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
460 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
461 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
462 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
463 assert(bufferPtr->myMateReferenceID ==
464 expectedRecordPtr->myMateReferenceID);
465 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
466 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
467
468 // Validate the variable length fields in the buffer.
469 // Set the pointer to the start of the variable fields.
470 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
471
472 // Validate the readname.
473 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
474 {
475 assert(*varPtr == samRecord.getReadName()[i]);
476 varPtr++;
477 }
478
479 // No cigar to validate.
480 // Validate the sequence.
481 // CT = 0x28
482 assert(*varPtr == 0x28);
483 varPtr++;
484 // GT = 0x48
485 assert(*varPtr == 0x48);
486 varPtr++;
487
488 // Validate the Quality
489 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
490 {
491 assert(*varPtr == samRecord.getQuality()[i] - 33);
492 varPtr++;
493 }
494
495 // No tags.
496}
497
498
499void validateRead3(SamRecord& samRecord)
500{
501 //////////////////////////////////////////
502 // Validate Record 3
503 // Create record structure for validating.
504 int expectedBlockSize = 87;
505 const char* expectedReferenceName = "1";
506 const char* expectedMateReferenceName = "18";
507 const char* expectedMateReferenceNameOrEqual = "18";
508
509 bamRecordStruct* expectedRecordPtr =
510 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
511
512 char tag[3];
513 char type;
514 void* value;
515 bamRecordStruct* bufferPtr;
516 unsigned char* varPtr;
517
518 expectedRecordPtr->myBlockSize = expectedBlockSize;
519 expectedRecordPtr->myReferenceID = 0;
520 expectedRecordPtr->myPosition = 74;
521 expectedRecordPtr->myReadNameLength = 21;
522 expectedRecordPtr->myMapQuality = 0;
523 expectedRecordPtr->myBin = 4681;
524 expectedRecordPtr->myCigarLength = 1;
525 expectedRecordPtr->myFlag = 97;
526 expectedRecordPtr->myReadLength = 5;
527 expectedRecordPtr->myMateReferenceID = 17;
528 expectedRecordPtr->myMatePosition = 756;
529 expectedRecordPtr->myInsertSize = 0;
530
531 // Check the accessors.
532 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
533 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
534 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
535 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
536 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
537 assert(samRecord.getReadNameLength() ==
538 expectedRecordPtr->myReadNameLength);
539 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
540 assert(samRecord.getBin() == expectedRecordPtr->myBin);
541 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
542 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
543 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
544 assert(samRecord.getMateReferenceID() ==
545 expectedRecordPtr->myMateReferenceID);
546 assert(strcmp(samRecord.getMateReferenceName(),
547 expectedMateReferenceName) == 0);
548 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
549 expectedMateReferenceNameOrEqual) == 0);
550 assert(samRecord.get1BasedMatePosition() ==
551 expectedRecordPtr->myMatePosition + 1);
552 assert(samRecord.get0BasedMatePosition() ==
553 expectedRecordPtr->myMatePosition);
554 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
555 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:295") == 0);
556 assert(strcmp(samRecord.getCigar(), "5M") == 0);
557 assert(strcmp(samRecord.getSequence(), "ACGTN") == 0);
558 assert(strcmp(samRecord.getQuality(), ";>>>>") == 0);
559 assert(samRecord.getNumOverlaps(74, 79) == 5);
560 assert(samRecord.getNumOverlaps(74, 78) == 4);
561 assert(samRecord.getNumOverlaps(73, 79) == 5);
562 assert(samRecord.getNumOverlaps(75, 79) == 4);
563 assert(samRecord.getNumOverlaps(0, 179) == 5);
564 assert(samRecord.getNumOverlaps(0, 19) == 0);
565
566 // Check the alignment end
567 assert(samRecord.get0BasedAlignmentEnd() == 78);
568 assert(samRecord.get1BasedAlignmentEnd() == 79);
569 assert(samRecord.getAlignmentLength() == 5);
570 assert(samRecord.get0BasedUnclippedStart() == 74);
571 assert(samRecord.get1BasedUnclippedStart() == 75);
572 assert(samRecord.get0BasedUnclippedEnd() == 78);
573 assert(samRecord.get1BasedUnclippedEnd() == 79);
574
575
576 // Check the tags.
577 assert(samRecord.getNextSamTag(tag, type, &value) == true);
578 assert(tag[0] == 'A');
579 assert(tag[1] == 'M');
580 assert(type == 'i');
581 assert(*(char*)value == 0);
582 assert(samRecord.getNextSamTag(tag, type, &value) == true);
583 assert(tag[0] == 'M');
584 assert(tag[1] == 'D');
585 assert(type == 'Z');
586 assert(*(String*)value == "30A0C5");
587 assert(samRecord.getNextSamTag(tag, type, &value) == true);
588 assert(tag[0] == 'N');
589 assert(tag[1] == 'M');
590 assert(type == 'i');
591 assert(*(char*)value == 2);
592 assert(samRecord.getNextSamTag(tag, type, &value) == true);
593 assert(tag[0] == 'X');
594 assert(tag[1] == 'T');
595 assert(type == 'A');
596 assert(*(char*)value == 'R');
597 // No more tags, should return false.
598 assert(samRecord.getNextSamTag(tag, type, &value) == false);
599 assert(samRecord.getNextSamTag(tag, type, &value) == false);
600
601 // Get the record ptr.
602 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
603 // Validate the buffers match.
604 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
605 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
606 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
607 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
608 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
609 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
610 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
611 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
612 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
613 assert(bufferPtr->myMateReferenceID ==
614 expectedRecordPtr->myMateReferenceID);
615 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
616 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
617
618 // Validate the variable length fields in the buffer.
619 // Set the pointer to the start of the variable fields.
620 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
621
622 // Validate the readname.
623 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
624 {
625 assert(*varPtr == samRecord.getReadName()[i]);
626 varPtr++;
627 }
628
629 // Validate the cigar.
630 // The cigar is 5M which is 5 << 4 | 0 = 80
631 assert(*(unsigned int*)varPtr == 80);
632 // Increment the varptr the size of an int.
633 varPtr += 4;
634
635 // Validate the sequence.
636 // AC = 0x12
637 assert(*varPtr == 0x12);
638 varPtr++;
639 // GT = 0x48
640 assert(*varPtr == 0x48);
641 varPtr++;
642 // N = 0xF0
643 assert(*varPtr == 0xF0);
644 varPtr++;
645
646 // Validate the Quality
647 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
648 {
649 assert(*varPtr == samRecord.getQuality()[i] - 33);
650 varPtr++;
651 }
652
653 // Validate the tags.
654 assert(*varPtr == 'A');
655 varPtr++;
656 assert(*varPtr == 'M');
657 varPtr++;
658 assert(*varPtr == 'C');
659 varPtr++;
660 assert(*varPtr == 0);
661 varPtr++;
662 assert(*varPtr == 'M');
663 varPtr++;
664 assert(*varPtr == 'D');
665 varPtr++;
666 assert(*varPtr == 'Z');
667 varPtr++;
668 assert(*varPtr == '3');
669 varPtr++;
670 assert(*varPtr == '0');
671 varPtr++;
672 assert(*varPtr == 'A');
673 varPtr++;
674 assert(*varPtr == '0');
675 varPtr++;
676 assert(*varPtr == 'C');
677 varPtr++;
678 assert(*varPtr == '5');
679 varPtr++;
680 assert(*varPtr == 0);
681 varPtr++;
682 assert(*varPtr == 'N');
683 varPtr++;
684 assert(*varPtr == 'M');
685 varPtr++;
686 assert(*varPtr == 'C');
687 varPtr++;
688 assert(*varPtr == 2);
689 varPtr++;
690 assert(*varPtr == 'X');
691 varPtr++;
692 assert(*varPtr == 'T');
693 varPtr++;
694 assert(*varPtr == 'A');
695 varPtr++;
696 assert(*varPtr == 'R');
697 varPtr++;
698}
699
700
701void validateRead4(SamRecord& samRecord)
702{
703 //////////////////////////////////////////
704 // Validate Record 4
705 // Create record structure for validating.
706 int expectedBlockSize = 57;
707 const char* expectedReferenceName = "1";
708 const char* expectedMateReferenceName = "18";
709 const char* expectedMateReferenceNameOrEqual = "18";
710
711 bamRecordStruct* expectedRecordPtr =
712 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
713
714 char tag[3];
715 char type;
716 void* value;
717 bamRecordStruct* bufferPtr;
718 unsigned char* varPtr;
719
720 expectedRecordPtr->myBlockSize = expectedBlockSize;
721 expectedRecordPtr->myReferenceID = 0;
722 expectedRecordPtr->myPosition = 74;
723 expectedRecordPtr->myReadNameLength = 21;
724 expectedRecordPtr->myMapQuality = 0;
725 expectedRecordPtr->myBin = 4681;
726 expectedRecordPtr->myCigarLength = 0;
727 expectedRecordPtr->myFlag = 97;
728 expectedRecordPtr->myReadLength = 0;
729 expectedRecordPtr->myMateReferenceID = 17;
730 expectedRecordPtr->myMatePosition = 756;
731 expectedRecordPtr->myInsertSize = 0;
732
733 // Check the alignment end
734 assert(samRecord.get1BasedUnclippedEnd() == 75);
735 assert(samRecord.get0BasedUnclippedEnd() == 74);
736 assert(samRecord.get0BasedUnclippedStart() == 74);
737 assert(samRecord.get1BasedUnclippedStart() == 75);
738 assert(samRecord.get1BasedAlignmentEnd() == 75);
739 assert(samRecord.get0BasedAlignmentEnd() == 74);
740 assert(samRecord.getAlignmentLength() == 0);
741
742 // Check the accessors.
743 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
744 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
745 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
746 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
747 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
748 assert(samRecord.getReadNameLength() ==
749 expectedRecordPtr->myReadNameLength);
750 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
751 assert(samRecord.getBin() == expectedRecordPtr->myBin);
752 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
753 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
754 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
755 assert(samRecord.getMateReferenceID() ==
756 expectedRecordPtr->myMateReferenceID);
757 assert(strcmp(samRecord.getMateReferenceName(),
758 expectedMateReferenceName) == 0);
759 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
760 expectedMateReferenceNameOrEqual) == 0);
761 assert(samRecord.get1BasedMatePosition() ==
762 expectedRecordPtr->myMatePosition + 1);
763 assert(samRecord.get0BasedMatePosition() ==
764 expectedRecordPtr->myMatePosition);
765 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
766 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:295") == 0);
767 assert(strcmp(samRecord.getCigar(), "*") == 0);
768 assert(strcmp(samRecord.getSequence(), "*") == 0);
769 assert(strcmp(samRecord.getQuality(), "*") == 0);
770
771 bool caught = false;
772 try
773 {
774 samRecord.getSequence(0);
775 }
776 catch (std::exception& e)
777 {
778 caught = true;
779 assert(strcmp(e.what(), "SamRecord::getSequence(0) is not allowed since sequence = '*'") == 0);
780 }
781 assert(caught == true);
782 caught = false;
783 try
784 {
785 assert(samRecord.getQuality(0) == BaseUtilities::UNKNOWN_QUALITY_CHAR);
786 }
787 catch (std::exception& e)
788 {
789 caught = true;
790 }
791 assert(caught == false);
792 try
793 {
794 samRecord.getSequence(-1);
795 }
796 catch (std::exception& e)
797 {
798 caught = true;
799 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is not allowed since sequence = '*'") == 0);
800 }
801 assert(caught == true);
802 caught = false;
803 try
804 {
805 assert(samRecord.getQuality(-1) == BaseUtilities::UNKNOWN_QUALITY_CHAR);
806 }
807 catch (std::exception& e)
808 {
809 caught = true;
810 }
811 assert(caught == false);
812
813 caught = false;
814 try
815 {
816 samRecord.getSequence(5);
817 }
818 catch (std::exception& e)
819 {
820 caught = true;
821 assert(strcmp(e.what(), "SamRecord::getSequence(5) is not allowed since sequence = '*'") == 0);
822 }
823 assert(caught == true);
824 caught = false;
825 try
826 {
827 assert(samRecord.getQuality(5) == BaseUtilities::UNKNOWN_QUALITY_CHAR);
828 }
829 catch (std::exception& e)
830 {
831 caught = true;
832 }
833 assert(caught == false);
834
835 assert(samRecord.getNumOverlaps(74, 79) == 0);
836 assert(samRecord.getNumOverlaps(74, 78) == 0);
837 assert(samRecord.getNumOverlaps(73, 79) == 0);
838 assert(samRecord.getNumOverlaps(75, 79) == 0);
839 assert(samRecord.getNumOverlaps(0, 179) == 0);
840 assert(samRecord.getNumOverlaps(0, 19) == 0);
841
842 // Check the tag.
843 assert(samRecord.getNextSamTag(tag, type, &value) == true);
844 assert(tag[0] == 'A');
845 assert(tag[1] == 'M');
846 assert(type == 'i');
847 assert(*(char*)value == 0);
848 // No more Tags to check, should return false.
849 assert(samRecord.getNextSamTag(tag, type, &value) == false);
850 assert(samRecord.getNextSamTag(tag, type, &value) == false);
851
852 // Get the record ptr.
853 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
854 // Validate the buffers match.
855 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
856 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
857 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
858 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
859 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
860 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
861 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
862 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
863 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
864 assert(bufferPtr->myMateReferenceID ==
865 expectedRecordPtr->myMateReferenceID);
866 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
867 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
868
869 // Validate the variable length fields in the buffer.
870 // Set the pointer to the start of the variable fields.
871 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
872
873 // Validate the readname.
874 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
875 {
876 assert(*varPtr == samRecord.getReadName()[i]);
877 varPtr++;
878 }
879
880 // No cigar to validate.
881 // Validate the sequence.
882 // No sequence.
883 // No Quality.
884
885 // Validate the tags.
886 assert(*varPtr == 'A');
887 varPtr++;
888 assert(*varPtr == 'M');
889 varPtr++;
890 assert(*varPtr == 'C');
891 varPtr++;
892 assert(*varPtr == 0);
893 varPtr++;
894}
895
896
897void validateRead5(SamRecord& samRecord)
898{
899 //////////////////////////////////////////
900 // Validate Record 5
901 int expectedBlockSize = 87;
902 const char* expectedReferenceName = "2";
903 const char* expectedMateReferenceName = "18";
904 const char* expectedMateReferenceNameOrEqual = "18";
905
906 bamRecordStruct* expectedRecordPtr =
907 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
908
909 char tag[3];
910 char type;
911 void* value;
912 bamRecordStruct* bufferPtr;
913 unsigned char* varPtr;
914
915 expectedRecordPtr->myBlockSize = expectedBlockSize;
916 expectedRecordPtr->myReferenceID = 1;
917 expectedRecordPtr->myPosition = 74;
918 expectedRecordPtr->myReadNameLength = 21;
919 expectedRecordPtr->myMapQuality = 0;
920 expectedRecordPtr->myBin = 4681;
921 expectedRecordPtr->myCigarLength = 1;
922 expectedRecordPtr->myFlag = 97;
923 expectedRecordPtr->myReadLength = 5;
924 expectedRecordPtr->myMateReferenceID = 17;
925 expectedRecordPtr->myMatePosition = 756;
926 expectedRecordPtr->myInsertSize = 0;
927
928 // Check the accessors.
929 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
930 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
931 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
932 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
933 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
934 assert(samRecord.getReadNameLength() ==
935 expectedRecordPtr->myReadNameLength);
936 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
937 assert(samRecord.getBin() == expectedRecordPtr->myBin);
938 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
939 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
940 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
941 assert(samRecord.getMateReferenceID() ==
942 expectedRecordPtr->myMateReferenceID);
943 assert(strcmp(samRecord.getMateReferenceName(),
944 expectedMateReferenceName) == 0);
945 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
946 expectedMateReferenceNameOrEqual) == 0);
947 assert(samRecord.get1BasedMatePosition() ==
948 expectedRecordPtr->myMatePosition + 1);
949 assert(samRecord.get0BasedMatePosition() ==
950 expectedRecordPtr->myMatePosition);
951 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
952 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:295") == 0);
953 assert(strcmp(samRecord.getCigar(), "5M") == 0);
954 assert(strcmp(samRecord.getSequence(), "ACGTN") == 0);
955 assert(strcmp(samRecord.getQuality(), "*") == 0);
956 assert(samRecord.getNumOverlaps(74, 79) == 5);
957 assert(samRecord.getNumOverlaps(74, 78) == 4);
958 assert(samRecord.getNumOverlaps(73, 79) == 5);
959 assert(samRecord.getNumOverlaps(75, 79) == 4);
960 assert(samRecord.getNumOverlaps(0, 179) == 5);
961 assert(samRecord.getNumOverlaps(0, 19) == 0);
962
963 assert(samRecord.getSequence(0) == 'A');
965 assert(samRecord.getQuality(0) == expChar);
966 assert(samRecord.getSequence(1) == 'C');
967 assert(samRecord.getQuality(1) == expChar);
968 assert(samRecord.getSequence(2) == 'G');
969 assert(samRecord.getQuality(2) == expChar);
970 assert(samRecord.getSequence(3) == 'T');
971 assert(samRecord.getQuality(3) == expChar);
972 assert(samRecord.getSequence(4) == 'N');
973 assert(samRecord.getQuality(4) == expChar);
974
975 bool caught = false;
976 try
977 {
978 samRecord.getSequence(-1);
979 }
980 catch (std::exception& e)
981 {
982 caught = true;
983 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is out of range. Index must be between 0 and 4") == 0);
984 }
985 assert(caught == true);
986 caught = false;
987 try
988 {
989 samRecord.getQuality(-1);
990 }
991 catch (std::exception& e)
992 {
993 caught = true;
994 assert(strcmp(e.what(), "SamRecord::getQuality(-1) is out of range. Index must be between 0 and 4") == 0);
995 }
996 assert(caught == true);
997
998 caught = false;
999 try
1000 {
1001 samRecord.getSequence(5);
1002 }
1003 catch (std::exception& e)
1004 {
1005 caught = true;
1006 assert(strcmp(e.what(), "SamRecord::getSequence(5) is out of range. Index must be between 0 and 4") == 0);
1007 }
1008 assert(caught == true);
1009 caught = false;
1010 try
1011 {
1012 samRecord.getQuality(5);
1013 }
1014 catch (std::exception& e)
1015 {
1016 caught = true;
1017 assert(strcmp(e.what(), "SamRecord::getQuality(5) is out of range. Index must be between 0 and 4") == 0);
1018 }
1019 assert(caught == true);
1020
1021 // Check the tags.
1022 assert(samRecord.getNextSamTag(tag, type, &value) == true);
1023 assert(tag[0] == 'A');
1024 assert(tag[1] == 'M');
1025 assert(type == 'i');
1026 assert(*(char*)value == 0);
1027 assert(samRecord.getNextSamTag(tag, type, &value) == true);
1028 assert(tag[0] == 'M');
1029 assert(tag[1] == 'D');
1030 assert(type == 'Z');
1031 assert(*(String*)value == "30A0C5");
1032 assert(samRecord.getNextSamTag(tag, type, &value) == true);
1033 assert(tag[0] == 'N');
1034 assert(tag[1] == 'M');
1035 assert(type == 'i');
1036 assert(*(char*)value == 2);
1037 assert(samRecord.getNextSamTag(tag, type, &value) == true);
1038 assert(tag[0] == 'X');
1039 assert(tag[1] == 'T');
1040 assert(type == 'A');
1041 assert(*(char*)value == 'R');
1042 // No more tags, should return false.
1043 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1044 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1045
1046 // Get the record ptr.
1047 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
1048 // Validate the buffers match.
1049 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
1050 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
1051 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
1052 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
1053 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
1054 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
1055 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
1056 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
1057 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
1058 assert(bufferPtr->myMateReferenceID ==
1059 expectedRecordPtr->myMateReferenceID);
1060 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
1061 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
1062
1063 // Validate the variable length fields in the buffer.
1064 // Set the pointer to the start of the variable fields.
1065 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
1066
1067 // Validate the readname.
1068 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
1069 {
1070 assert(*varPtr == samRecord.getReadName()[i]);
1071 varPtr++;
1072 }
1073
1074 // Validate the cigar.
1075 // The cigar is 5M which is 5 << 4 | 0 = 80
1076 assert(*(unsigned int*)varPtr == 80);
1077 // Increment the varptr the size of an int.
1078 varPtr += 4;
1079
1080 // Validate the sequence.
1081 // AC = 0x12
1082 assert(*varPtr == 0x12);
1083 varPtr++;
1084 // GT = 0x48
1085 assert(*varPtr == 0x48);
1086 varPtr++;
1087 // N = 0xF0
1088 assert(*varPtr == 0xF0);
1089 varPtr++;
1090
1091 // Validate the Quality
1092 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
1093 {
1094 assert(*varPtr == 0xFF);
1095 varPtr++;
1096 }
1097
1098 // Validate the tags.
1099 assert(*varPtr == 'A');
1100 varPtr++;
1101 assert(*varPtr == 'M');
1102 varPtr++;
1103 assert(*varPtr == 'C');
1104 varPtr++;
1105 assert(*varPtr == 0);
1106 varPtr++;
1107 assert(*varPtr == 'M');
1108 varPtr++;
1109 assert(*varPtr == 'D');
1110 varPtr++;
1111 assert(*varPtr == 'Z');
1112 varPtr++;
1113 assert(*varPtr == '3');
1114 varPtr++;
1115 assert(*varPtr == '0');
1116 varPtr++;
1117 assert(*varPtr == 'A');
1118 varPtr++;
1119 assert(*varPtr == '0');
1120 varPtr++;
1121 assert(*varPtr == 'C');
1122 varPtr++;
1123 assert(*varPtr == '5');
1124 varPtr++;
1125 assert(*varPtr == 0);
1126 varPtr++;
1127 assert(*varPtr == 'N');
1128 varPtr++;
1129 assert(*varPtr == 'M');
1130 varPtr++;
1131 assert(*varPtr == 'C');
1132 varPtr++;
1133 assert(*varPtr == 2);
1134 varPtr++;
1135 assert(*varPtr == 'X');
1136 varPtr++;
1137 assert(*varPtr == 'T');
1138 varPtr++;
1139 assert(*varPtr == 'A');
1140 varPtr++;
1141 assert(*varPtr == 'R');
1142 varPtr++;
1143}
1144
1145
1146void validateRead6(SamRecord& samRecord)
1147{
1148 //////////////////////////////////////////
1149 // Validate Record 6
1150 // Create record structure for validating.
1151 int expectedBlockSize = 77;
1152 const char* expectedReferenceName = "1";
1153 const char* expectedMateReferenceName = "18";
1154 const char* expectedMateReferenceNameOrEqual = "18";
1155
1156 bamRecordStruct* expectedRecordPtr =
1157 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
1158
1159 char tag[3];
1160 char type;
1161 void* value;
1162 bamRecordStruct* bufferPtr;
1163 unsigned char* varPtr;
1164
1165 expectedRecordPtr->myBlockSize = expectedBlockSize;
1166 expectedRecordPtr->myReferenceID = 0;
1167 expectedRecordPtr->myPosition = TestValidate::READ6_POS;
1168 expectedRecordPtr->myReadNameLength = 21;
1169 expectedRecordPtr->myMapQuality = 0;
1170 expectedRecordPtr->myBin = 4681;
1171 expectedRecordPtr->myCigarLength = 3;
1172 expectedRecordPtr->myFlag = 97;
1173 expectedRecordPtr->myReadLength = 8;
1174 expectedRecordPtr->myMateReferenceID = 17;
1175 expectedRecordPtr->myMatePosition = 756;
1176 expectedRecordPtr->myInsertSize = 0;
1177
1178 // Check the accessors.
1179 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
1180 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
1181 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
1182 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
1183 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
1184 assert(samRecord.getReadNameLength() ==
1185 expectedRecordPtr->myReadNameLength);
1186 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
1187 assert(samRecord.getBin() == expectedRecordPtr->myBin);
1188 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
1189 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
1190 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
1191 assert(samRecord.getMateReferenceID() ==
1192 expectedRecordPtr->myMateReferenceID);
1193 assert(strcmp(samRecord.getMateReferenceName(),
1194 expectedMateReferenceName) == 0);
1195 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
1196 expectedMateReferenceNameOrEqual) == 0);
1197 assert(samRecord.get1BasedMatePosition() ==
1198 expectedRecordPtr->myMatePosition + 1);
1199 assert(samRecord.get0BasedMatePosition() ==
1200 expectedRecordPtr->myMatePosition);
1201 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
1202 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:296") == 0);
1203 assert(samRecord.getCigar() == TestValidate::READ6_CIGAR);
1204 assert(samRecord.getSequence() == TestValidate::READ6_SEQ);
1205 assert(samRecord.getQuality() == TestValidate::READ6_QUAL);
1206 assert(samRecord.getNumOverlaps(1750, 1755) == 5);
1207 assert(samRecord.getNumOverlaps(1750, 1754) == 4);
1208 assert(samRecord.getNumOverlaps(0, 2000) == 5);
1209 assert(samRecord.getNumOverlaps(1749, 1755) == 5);
1210 assert(samRecord.getNumOverlaps(1751, 1755) == 4);
1211 assert(samRecord.getNumOverlaps(0, 1752) == 2);
1212 assert(samRecord.getNumOverlaps(0, 19) == 0);
1213
1214 // Check the alignment end
1215 assert(samRecord.get0BasedAlignmentEnd() == TestValidate::READ6_ALIGN_END);
1216 assert(samRecord.get1BasedAlignmentEnd() == (TestValidate::READ6_ALIGN_END + 1));
1217 assert(samRecord.getAlignmentLength() == TestValidate::READ6_ALIGN_LEN);
1218 assert(samRecord.get0BasedUnclippedStart() == TestValidate::READ6_UNCLIP_START);
1219 assert(samRecord.get1BasedUnclippedStart() == (TestValidate::READ6_UNCLIP_START + 1));
1220 assert(samRecord.get0BasedUnclippedEnd() == TestValidate::READ6_UNCLIP_END);
1221 assert(samRecord.get1BasedUnclippedEnd() == (TestValidate::READ6_UNCLIP_END + 1));
1222
1223 // No tags.
1224 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1225
1226 // Get the record ptr.
1227 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
1228 // Validate the buffers match.
1229 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
1230 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
1231 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
1232 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
1233 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
1234 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
1235 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
1236 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
1237 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
1238 assert(bufferPtr->myMateReferenceID ==
1239 expectedRecordPtr->myMateReferenceID);
1240 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
1241 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
1242
1243 // Validate the variable length fields in the buffer.
1244 // Set the pointer to the start of the variable fields.
1245 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
1246
1247 // Validate the readname.
1248 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
1249 {
1250 assert(*varPtr == samRecord.getReadName()[i]);
1251 varPtr++;
1252 }
1253
1254 // Validate the cigar.
1255 // The cigar is 3S2H5M which is:
1256 // 3S: 3 << 4 | 4 = 0x34
1257 assert(*(unsigned int*)varPtr == 0x34);
1258 // Increment the varptr the size of an int.
1259 varPtr += 4;
1260 // 2H: 2 << 4 | 5 = 0x25
1261 assert(*(unsigned int*)varPtr == 0x25);
1262 // Increment the varptr the size of an int.
1263 varPtr += 4;
1264 // 5M: 5 << 4 | 0 = 0x50
1265 assert(*(unsigned int*)varPtr == 0x50);
1266 // Increment the varptr the size of an int.
1267 varPtr += 4;
1268
1269 // Validate the sequence.
1270 // TG = 0x84
1271 assert(*varPtr == 0x84);
1272 varPtr++;
1273 // CA = 0x21
1274 assert(*varPtr == 0x21);
1275 varPtr++;
1276 // CG = 0x24
1277 assert(*varPtr == 0x24);
1278 varPtr++;
1279 // TN = 0x8F
1280 assert(*varPtr == 0x8F);
1281 varPtr++;
1282
1283 // Validate the Quality
1284 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
1285 {
1286 assert(*varPtr == samRecord.getQuality()[i] - 33);
1287 varPtr++;
1288 }
1289}
1290
1291
1292void validateRead7(SamRecord& samRecord)
1293{
1294 //////////////////////////////////////////
1295 // Validate Record 7
1296 // Create record structure for validating.
1297 int expectedBlockSize = 83;
1298 const char* expectedReferenceName = "2";
1299 const char* expectedMateReferenceName = "18";
1300 const char* expectedMateReferenceNameOrEqual = "18";
1301
1302 bamRecordStruct* expectedRecordPtr =
1303 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
1304
1305 char tag[3];
1306 char type;
1307 void* value;
1308 bamRecordStruct* bufferPtr;
1309 unsigned char* varPtr;
1310
1311 expectedRecordPtr->myBlockSize = expectedBlockSize;
1312 expectedRecordPtr->myReferenceID = 1;
1313 expectedRecordPtr->myPosition = TestValidate::READ7_POS;
1314 expectedRecordPtr->myReadNameLength = 21;
1315 expectedRecordPtr->myMapQuality = 0;
1316 expectedRecordPtr->myBin = 4681;
1317 expectedRecordPtr->myCigarLength = 4;
1318 expectedRecordPtr->myFlag = 97;
1319 expectedRecordPtr->myReadLength = 9;
1320 expectedRecordPtr->myMateReferenceID = 17;
1321 expectedRecordPtr->myMatePosition = 756;
1322 expectedRecordPtr->myInsertSize = 0;
1323
1324 // Check the accessors.
1325 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
1326 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
1327 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
1328 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
1329 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
1330 assert(samRecord.getReadNameLength() ==
1331 expectedRecordPtr->myReadNameLength);
1332 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
1333 assert(samRecord.getBin() == expectedRecordPtr->myBin);
1334 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
1335 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
1336 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
1337 assert(samRecord.getMateReferenceID() ==
1338 expectedRecordPtr->myMateReferenceID);
1339 assert(strcmp(samRecord.getMateReferenceName(),
1340 expectedMateReferenceName) == 0);
1341 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
1342 expectedMateReferenceNameOrEqual) == 0);
1343 assert(samRecord.get1BasedMatePosition() ==
1344 expectedRecordPtr->myMatePosition + 1);
1345 assert(samRecord.get0BasedMatePosition() ==
1346 expectedRecordPtr->myMatePosition);
1347 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
1348 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:297") == 0);
1349 assert(samRecord.getCigar() == TestValidate::READ7_CIGAR);
1350 assert(samRecord.getSequence() == TestValidate::READ7_SEQ);
1351 assert(samRecord.getQuality() == TestValidate::READ7_QUAL);
1352 assert(samRecord.getNumOverlaps(1750, 1755) == 5);
1353 assert(samRecord.getNumOverlaps(1750, 1754) == 4);
1354 assert(samRecord.getNumOverlaps(0, 2000) == 5);
1355 assert(samRecord.getNumOverlaps(1749, 1755) == 5);
1356 assert(samRecord.getNumOverlaps(1751, 1755) == 4);
1357 assert(samRecord.getNumOverlaps(0, 1752) == 2);
1358 assert(samRecord.getNumOverlaps(0, 19) == 0);
1359
1360 // Check the alignment end
1361 assert(samRecord.get0BasedAlignmentEnd() == TestValidate::READ7_ALIGN_END);
1362 assert(samRecord.get1BasedAlignmentEnd() == (TestValidate::READ7_ALIGN_END + 1));
1363 assert(samRecord.getAlignmentLength() == TestValidate::READ7_ALIGN_LEN);
1364 assert(samRecord.get0BasedUnclippedStart() == TestValidate::READ7_UNCLIP_START);
1365 assert(samRecord.get1BasedUnclippedStart() == (TestValidate::READ7_UNCLIP_START + 1));
1366 assert(samRecord.get0BasedUnclippedEnd() == TestValidate::READ7_UNCLIP_END);
1367 assert(samRecord.get1BasedUnclippedEnd() == (TestValidate::READ7_UNCLIP_END + 1));
1368
1369 // No tags.
1370 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1371
1372 // Get the record ptr.
1373 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
1374 // Validate the buffers match.
1375 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
1376 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
1377 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
1378 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
1379 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
1380 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
1381 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
1382 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
1383 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
1384 assert(bufferPtr->myMateReferenceID ==
1385 expectedRecordPtr->myMateReferenceID);
1386 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
1387 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
1388
1389 // Validate the variable length fields in the buffer.
1390 // Set the pointer to the start of the variable fields.
1391 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
1392
1393 // Validate the readname.
1394 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
1395 {
1396 assert(*varPtr == samRecord.getReadName()[i]);
1397 varPtr++;
1398 }
1399
1400 // Validate the cigar.
1401 // The cigar is 3S5M1S3H which is:
1402 // 3S: 3 << 4 | 4 = 0x34
1403 assert(*(unsigned int*)varPtr == 0x34);
1404 // Increment the varptr the size of an int.
1405 varPtr += 4;
1406 // 5M: 5 << 4 | 0 = 0x50
1407 assert(*(unsigned int*)varPtr == 0x50);
1408 // Increment the varptr the size of an int.
1409 varPtr += 4;
1410 // 1S: 1 << 4 | 4 = 0x14
1411 assert(*(unsigned int*)varPtr == 0x14);
1412 // Increment the varptr the size of an int.
1413 varPtr += 4;
1414 // 3H: 3 << 4 | 5 = 0x35
1415 assert(*(unsigned int*)varPtr == 0x35);
1416 // Increment the varptr the size of an int.
1417 varPtr += 4;
1418
1419 // Validate the sequence.
1420 // TG = 0x84
1421 assert(*varPtr == 0x84);
1422 varPtr++;
1423 // CA = 0x21
1424 assert(*varPtr == 0x21);
1425 varPtr++;
1426 // CG = 0x24
1427 assert(*varPtr == 0x24);
1428 varPtr++;
1429 // TN = 0x8F
1430 assert(*varPtr == 0x8F);
1431 varPtr++;
1432 // G = 0x40
1433 assert(*varPtr == 0x40);
1434 varPtr++;
1435
1436 // Validate the Quality
1437 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
1438 {
1439 assert(*varPtr == samRecord.getQuality()[i] - 33);
1440 varPtr++;
1441 }
1442}
1443
1444
1445void validateRead8(SamRecord& samRecord)
1446{
1447 //////////////////////////////////////////
1448 // Validate Record 8
1449 // Create record structure for validating.
1450 int expectedBlockSize = 65;
1451 const char* expectedReferenceName = "*";
1452 const char* expectedMateReferenceName = "*";
1453 const char* expectedMateReferenceNameOrEqual = "*";
1454
1455 bamRecordStruct* expectedRecordPtr =
1456 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
1457
1458 char tag[3];
1459 char type;
1460 void* value;
1461 bamRecordStruct* bufferPtr;
1462 unsigned char* varPtr;
1463
1464 expectedRecordPtr->myBlockSize = expectedBlockSize;
1465 expectedRecordPtr->myReferenceID = -1;
1466 expectedRecordPtr->myPosition = -1;
1467 expectedRecordPtr->myReadNameLength = 27;
1468 expectedRecordPtr->myMapQuality = 0;
1469 expectedRecordPtr->myBin = 4680;
1470 expectedRecordPtr->myCigarLength = 0;
1471 expectedRecordPtr->myFlag = 141;
1472 expectedRecordPtr->myReadLength = 4;
1473 expectedRecordPtr->myMateReferenceID = -1;
1474 expectedRecordPtr->myMatePosition = -1;
1475 expectedRecordPtr->myInsertSize = 0;
1476
1477 // Check the alignment end
1478 assert(samRecord.get0BasedAlignmentEnd() == -1);
1479 assert(samRecord.get1BasedAlignmentEnd() == 0);
1480 assert(samRecord.getAlignmentLength() == 0);
1481 assert(samRecord.get0BasedUnclippedStart() == -1);
1482 assert(samRecord.get1BasedUnclippedStart() == 0);
1483 assert(samRecord.get0BasedUnclippedEnd() == -1);
1484 assert(samRecord.get1BasedUnclippedEnd() == 0);
1485
1486 // Check the accessors.
1487 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
1488 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
1489 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
1490 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
1491 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
1492 assert(samRecord.getReadNameLength() ==
1493 expectedRecordPtr->myReadNameLength);
1494 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
1495 assert(samRecord.getBin() == expectedRecordPtr->myBin);
1496 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
1497 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
1498 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
1499 assert(samRecord.getMateReferenceID() ==
1500 expectedRecordPtr->myMateReferenceID);
1501 assert(strcmp(samRecord.getMateReferenceName(),
1502 expectedMateReferenceName) == 0);
1503 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
1504 expectedMateReferenceNameOrEqual) == 0);
1505 assert(samRecord.get1BasedMatePosition() ==
1506 expectedRecordPtr->myMatePosition + 1);
1507 assert(samRecord.get0BasedMatePosition() ==
1508 expectedRecordPtr->myMatePosition);
1509 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
1510 assert(strcmp(samRecord.getReadName(), "Y:16597235+13M13I11M:F:181") == 0);
1511 assert(strcmp(samRecord.getCigar(), "*") == 0);
1512 assert(strcmp(samRecord.getSequence(), "AACT") == 0);
1513 assert(strcmp(samRecord.getQuality(), "==;;") == 0);
1514 assert(samRecord.getNumOverlaps(1750, 1755) == 0);
1515 assert(samRecord.getNumOverlaps(1750, 1754) == 0);
1516 assert(samRecord.getNumOverlaps(0, 2000) == 0);
1517 assert(samRecord.getNumOverlaps(1749, 1755) == 0);
1518 assert(samRecord.getNumOverlaps(1751, 1755) == 0);
1519 assert(samRecord.getNumOverlaps(0, 1752) == 0);
1520 assert(samRecord.getNumOverlaps(0, 19) == 0);
1521 assert(samRecord.getNumOverlaps(-1, 4) == 0);
1522
1523 // No Tags to check, should return false.
1524 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1525 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1526
1527 // Get the record ptr.
1528 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
1529 // Validate the buffers match.
1530 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
1531 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
1532 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
1533 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
1534 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
1535 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
1536 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
1537 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
1538 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
1539 assert(bufferPtr->myMateReferenceID ==
1540 expectedRecordPtr->myMateReferenceID);
1541 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
1542 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
1543
1544 // Validate the variable length fields in the buffer.
1545 // Set the pointer to the start of the variable fields.
1546 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
1547
1548 // Validate the readname.
1549 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
1550 {
1551 assert(*varPtr == samRecord.getReadName()[i]);
1552 varPtr++;
1553 }
1554
1555 // No cigar to validate.
1556 // Validate the sequence.
1557 // AA = 0x11
1558 assert(*varPtr == 0x11);
1559 varPtr++;
1560 // CT = 0x28
1561 assert(*varPtr == 0x28);
1562 varPtr++;
1563
1564 // Validate the Quality
1565 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
1566 {
1567 assert(*varPtr == samRecord.getQuality()[i] - 33);
1568 varPtr++;
1569 }
1570
1571 // No tags.
1572}
1573
1574
1575void validateRead9(SamRecord& samRecord)
1576{
1577 //////////////////////////////////////////
1578 // Validate Record 9
1579 // Create record structure for validating.
1580 int expectedBlockSize = 77;
1581 const char* expectedReferenceName = "3";
1582 const char* expectedMateReferenceName = "18";
1583 const char* expectedMateReferenceNameOrEqual = "18";
1584
1585 bamRecordStruct* expectedRecordPtr =
1586 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
1587
1588 char tag[3];
1589 char type;
1590 void* value;
1591 bamRecordStruct* bufferPtr;
1592 unsigned char* varPtr;
1593
1594 expectedRecordPtr->myBlockSize = expectedBlockSize;
1595 expectedRecordPtr->myReferenceID = 2;
1596 expectedRecordPtr->myPosition = 74;
1597 expectedRecordPtr->myReadNameLength = 21;
1598 expectedRecordPtr->myMapQuality = 0;
1599 expectedRecordPtr->myBin = 4681;
1600 expectedRecordPtr->myCigarLength = 3;
1601 expectedRecordPtr->myFlag = 97;
1602 expectedRecordPtr->myReadLength = 8;
1603 expectedRecordPtr->myMateReferenceID = 17;
1604 expectedRecordPtr->myMatePosition = 756;
1605 expectedRecordPtr->myInsertSize = 0;
1606
1607 // Check the accessors.
1608 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
1609 assert(samRecord.getStatus() == SamStatus::SUCCESS);
1610 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
1611 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
1612 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
1613 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
1614 assert(samRecord.getReadNameLength() ==
1615 expectedRecordPtr->myReadNameLength);
1616 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
1617 assert(samRecord.getBin() == expectedRecordPtr->myBin);
1618 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
1619 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
1620 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
1621 assert(samRecord.getMateReferenceID() ==
1622 expectedRecordPtr->myMateReferenceID);
1623 assert(strcmp(samRecord.getMateReferenceName(),
1624 expectedMateReferenceName) == 0);
1625 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
1626 expectedMateReferenceNameOrEqual) == 0);
1627 assert(samRecord.get1BasedMatePosition() ==
1628 expectedRecordPtr->myMatePosition + 1);
1629 assert(samRecord.get0BasedMatePosition() ==
1630 expectedRecordPtr->myMatePosition);
1631 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
1632 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:298") == 0);
1633 assert(strcmp(samRecord.getCigar(), "3S5M4H") == 0);
1634 assert((strcmp(samRecord.getSequence(), "TGCACGTN") == 0) ||
1635 (strcmp(samRecord.getSequence(), "tgcacgtn") == 0));
1636 assert(strcmp(samRecord.getQuality(), "453;>>>>") == 0);
1637 assert(samRecord.getNumOverlaps(74, 79) == 5);
1638 assert(samRecord.getNumOverlaps(73, 79) == 5);
1639 assert(samRecord.getNumOverlaps(75, 78) == 3);
1640 assert(samRecord.getNumOverlaps(0, 1017) == 5);
1641 assert(samRecord.getNumOverlaps(79, 85) == 0);
1642 assert(samRecord.getNumOverlaps(78, 85) == 1);
1643 assert(samRecord.getNumOverlaps(-1, 1017) == 5);
1644
1645 // Check the alignment end
1646 assert(samRecord.get0BasedAlignmentEnd() == 78);
1647 assert(samRecord.get1BasedAlignmentEnd() == 79);
1648 assert(samRecord.getAlignmentLength() == 5);
1649 assert(samRecord.get0BasedUnclippedStart() == 71);
1650 assert(samRecord.get1BasedUnclippedStart() == 72);
1651 assert(samRecord.get0BasedUnclippedEnd() == 82);
1652 assert(samRecord.get1BasedUnclippedEnd() == 83);
1653
1654 // No tags.
1655 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1656
1657 // Get the record ptr.
1658 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
1659 assert(bufferPtr != NULL);
1660 // Validate the buffers match.
1661 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
1662 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
1663 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
1664 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
1665 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
1666 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
1667 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
1668 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
1669 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
1670 assert(bufferPtr->myMateReferenceID ==
1671 expectedRecordPtr->myMateReferenceID);
1672 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
1673 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
1674
1675 // Validate the variable length fields in the buffer.
1676 // Set the pointer to the start of the variable fields.
1677 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
1678
1679 // Validate the readname.
1680 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
1681 {
1682 assert(*varPtr == samRecord.getReadName()[i]);
1683 varPtr++;
1684 }
1685
1686 // Validate the cigar.
1687 // The cigar is 3S5M1S3H which is:
1688 // 3S: 3 << 4 | 4 = 0x34
1689 assert(*(unsigned int*)varPtr == 0x34);
1690 // Increment the varptr the size of an int.
1691 varPtr += 4;
1692 // 5M: 5 << 4 | 0 = 0x50
1693 assert(*(unsigned int*)varPtr == 0x50);
1694 // Increment the varptr the size of an int.
1695 varPtr += 4;
1696 // 4H: 4 << 4 | 5 = 0x45
1697 assert(*(unsigned int*)varPtr == 0x45);
1698 // Increment the varptr the size of an int.
1699 varPtr += 4;
1700
1701 // Validate the sequence.
1702 // TG = 0x84
1703 assert(*varPtr == 0x84);
1704 varPtr++;
1705 // CA = 0x21
1706 assert(*varPtr == 0x21);
1707 varPtr++;
1708 // CG = 0x24
1709 assert(*varPtr == 0x24);
1710 varPtr++;
1711 // TN = 0x8F
1712 assert(*varPtr == 0x8F);
1713 varPtr++;
1714
1715 // Validate the Quality
1716 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
1717 {
1718 assert(*varPtr == samRecord.getQuality()[i] - 33);
1719 varPtr++;
1720 }
1721}
1722
1723
1724void validateRead10(SamRecord& samRecord)
1725{
1726 //////////////////////////////////////////
1727 // Validate Record 10
1728 // Create record structure for validating.
1729 int expectedBlockSize = 59;
1730 const char* expectedReferenceName = "*";
1731 const char* expectedMateReferenceName = "*";
1732 const char* expectedMateReferenceNameOrEqual = "*";
1733
1734 bamRecordStruct* expectedRecordPtr =
1735 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
1736
1737 char tag[3];
1738 char type;
1739 void* value;
1740 bamRecordStruct* bufferPtr;
1741 unsigned char* varPtr;
1742
1743 expectedRecordPtr->myBlockSize = expectedBlockSize;
1744 expectedRecordPtr->myReferenceID = -1;
1745 expectedRecordPtr->myPosition = -1;
1746 expectedRecordPtr->myReadNameLength = 27;
1747 expectedRecordPtr->myMapQuality = 0;
1748 expectedRecordPtr->myBin = 4680;
1749 expectedRecordPtr->myCigarLength = 0;
1750 expectedRecordPtr->myFlag = 141;
1751 expectedRecordPtr->myReadLength = 0;
1752 expectedRecordPtr->myMateReferenceID = -1;
1753 expectedRecordPtr->myMatePosition = -1;
1754 expectedRecordPtr->myInsertSize = 0;
1755
1756 // Check the alignment end
1757 assert(samRecord.get0BasedUnclippedStart() == -1);
1758 assert(samRecord.get1BasedUnclippedStart() == 0);
1759 assert(samRecord.get0BasedUnclippedEnd() == -1);
1760 assert(samRecord.get1BasedUnclippedEnd() == 0);
1761 assert(samRecord.get1BasedAlignmentEnd() == 0);
1762 assert(samRecord.get0BasedAlignmentEnd() == -1);
1763 assert(samRecord.getAlignmentLength() == 0);
1764
1765 // Check the accessors.
1766 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
1767 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
1768 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
1769 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
1770 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
1771 assert(samRecord.getReadNameLength() ==
1772 expectedRecordPtr->myReadNameLength);
1773 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
1774 assert(samRecord.getBin() == expectedRecordPtr->myBin);
1775 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
1776 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
1777 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
1778 assert(samRecord.getMateReferenceID() ==
1779 expectedRecordPtr->myMateReferenceID);
1780 assert(strcmp(samRecord.getMateReferenceName(),
1781 expectedMateReferenceName) == 0);
1782 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
1783 expectedMateReferenceNameOrEqual) == 0);
1784 assert(samRecord.get1BasedMatePosition() ==
1785 expectedRecordPtr->myMatePosition + 1);
1786 assert(samRecord.get0BasedMatePosition() ==
1787 expectedRecordPtr->myMatePosition);
1788 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
1789 assert(strcmp(samRecord.getReadName(), "Y:16597235+13M13I11M:F:181") == 0);
1790 assert(strcmp(samRecord.getCigar(), "*") == 0);
1791 assert(strcmp(samRecord.getSequence(), "*") == 0);
1792 assert(strcmp(samRecord.getQuality(), "*") == 0);
1793 assert(samRecord.getNumOverlaps(74, 79) == 0);
1794 assert(samRecord.getNumOverlaps(73, 79) == 0);
1795 assert(samRecord.getNumOverlaps(75, 78) == 0);
1796 assert(samRecord.getNumOverlaps(0, 1017) == 0);
1797 assert(samRecord.getNumOverlaps(79, 85) == 0);
1798 assert(samRecord.getNumOverlaps(78, 85) == 0);
1799 assert(samRecord.getNumOverlaps(-1, 1017) == 0);
1800
1801 // No Tags to check, should return false.
1802 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1803 assert(samRecord.getNextSamTag(tag, type, &value) == false);
1804
1805 // Get the record ptr.
1806 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
1807 // Validate the buffers match.
1808 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
1809 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
1810 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
1811 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
1812 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
1813 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
1814 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
1815 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
1816 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
1817 assert(bufferPtr->myMateReferenceID ==
1818 expectedRecordPtr->myMateReferenceID);
1819 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
1820 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
1821
1822 // Validate the variable length fields in the buffer.
1823 // Set the pointer to the start of the variable fields.
1824 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
1825
1826 // Validate the readname.
1827 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
1828 {
1829 assert(*varPtr == samRecord.getReadName()[i]);
1830 varPtr++;
1831 }
1832
1833 // No cigar to validate.
1834 // No sequence.
1835 // No Quality.
1836 // No Tags.
1837}
1838
1839
1840void validateHeader(SamFileHeader& samHeader)
1841{
1842 validateHeaderFields(samHeader);
1843 validateHeaderString(samHeader);
1844}
1845
1846
1847void validateHeaderFields(SamFileHeader& samHeader)
1848{
1849 const char* value;
1850
1851 ////////////////////////////////////////////////////////
1852 // Test getting a specific HD Tag value from the header
1853 // that does not exist.
1854 value = samHeader.getHDTagValue("GO");
1855 assert(strcmp(value, "") == 0);
1856
1857 ////////////////////////////////////////////////////////
1858 // Test getting a specific PG Tag value from the header
1859 // that does not exist.
1860 value = samHeader.getPGTagValue("CL", "1");
1861 assert(strcmp(value, "") == 0);
1862
1863 ////////////////////////////////////////////////////////
1864 // Test getting a specific SQ Tag value from the header
1865 value = samHeader.getSQTagValue("LN", "1");
1866 assert(value != NULL);
1867 assert(strcmp(value, "247249719") == 0);
1868 value = samHeader.getSQTagValue("LN", "22");
1869 assert(value != NULL);
1870 assert(strcmp(value, "49691432") == 0);
1871
1872 ////////////////////////////////////////////////////////
1873 // Test getting a specific SQ Tag value from the header
1874 // that does not exist.
1875 value = samHeader.getSQTagValue("LN", "1000");
1876 assert(strcmp(value, "") == 0);
1877
1878 ////////////////////////////////////////////////////////
1879 // Test getting a specific SQ Tag value from the header
1880 // that does not exist - sq exists, but not with that tag.
1881 value = samHeader.getSQTagValue("AS", "1");
1882 assert(strcmp(value, "") == 0);
1883
1884 ////////////////////////////////////////////////////////
1885 // Test getting a specific RG Tag value from the header
1886 value = samHeader.getRGTagValue("LB", "myID2");
1887 assert(value != NULL);
1888 assert(strcmp(value, "library2") == 0);
1889 value = samHeader.getRGTagValue("LB", "myID");
1890 assert(value != NULL);
1891 assert(strcmp(value, "library") == 0);
1892
1893 ////////////////////////////////////////////////////////
1894 // Test getting a specific SQ from the header
1895 // Then pulling the tags out of it.
1896 SamHeaderSQ* sq = samHeader.getSQ("10");
1897 assert(strcmp(sq->getTagValue("SN"), "10") == 0);
1898 assert(strcmp(sq->getTagValue("LN"), "135374737") == 0);
1899
1900 // Test pulling a tag that does not exist.
1901 assert(strcmp(sq->getTagValue("DD"), "") == 0);
1902
1903
1904 ////////////////////////////////////////////////////////
1905 // Test getting a specific RG from the header
1906 // Then pulling the tags out of it.
1907 const SamHeaderRG* rg = samHeader.getRG("myID");
1908 assert(strcmp(rg->getTagValue("ID"), "myID") == 0);
1909 assert(strcmp(rg->getTagValue("SM"), "sample") == 0);
1910 assert(strcmp(rg->getTagValue("LB"), "library") == 0);
1911
1912 // Test pulling a tag that does not exist.
1913 assert(strcmp(rg->getTagValue("DD"), "") == 0);
1914
1915 ////////////////////////////////////////////////////////
1916 // Test getting a specific RG from the header that does not exist.
1917 rg = samHeader.getRG("noExist");
1918 assert(rg == NULL);
1919
1920 ////////////////////////////////////////////////////////
1921 // Test getting a specific SQ from the header that does not exist.
1922 sq = samHeader.getSQ("noExist");
1923 assert(sq == NULL);
1924
1925 ////////////////////////////////////////////////////////
1926 // Test getting the reference ID.
1927 assert(samHeader.getReferenceID("2") == 1);
1928 std::string refIDStdString = "X";
1929 assert(samHeader.getReferenceID(refIDStdString.c_str()) == 22);
1930 String refIDString = "22";
1931 assert(samHeader.getReferenceID(refIDString) == 21);
1932 assert(samHeader.getReferenceID(refIDString.c_str()) == 21);
1933 assert(samHeader.getReferenceID("Z") == SamReferenceInfo::NO_REF_ID);
1934 assert(samHeader.getReferenceID("Z", true) == 23);
1935 assert(samHeader.getReferenceID("*") == -1);
1936 refIDString = "*";
1937 assert(samHeader.getReferenceID(refIDString) == -1);
1938 assert(samHeader.getReferenceID(refIDString.c_str()) == -1);
1939}
1940
1941void validateHeaderString(SamFileHeader& samHeader)
1942{
1943 // Check the header line.
1944 std::string headerString = "";
1945 assert(samHeader.getHeaderString(headerString) == true);
1946 assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:11\tLN:134452384\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\tLB:library2\n@CO\tComment 1\n@CO\tComment 2\n");
1947}
static const char UNKNOWN_QUALITY_CHAR
Character used when the quality is unknown.
Definition: BaseUtilities.h:49
This class allows a user to get/set the fields in a SAM/BAM Header.
Definition: SamFileHeader.h:35
const char * getSQTagValue(const char *tag, const char *name)
Get the value associated with the specified tag on the SQ line with the specified sequence name,...
SamHeaderSQ * getSQ(const char *name)
Get the SQ object with the specified sequence name, returning NULL if there is no SQ object with that...
const char * getHDTagValue(const char *tag)
Returns the value associated with the specified HD tag, returning "" if the tag does not exist in the...
int getReferenceID(const String &referenceName, bool addID=false)
Get the reference ID for the specified reference name (chromosome).
const char * getRGTagValue(const char *tag, const char *id)
Get the value associated with the specified tag on the RG line with the specified read group identifi...
bool getHeaderString(std::string &header) const
Set the passed in string to the entire header string, clearing its current contents.
const char * getPGTagValue(const char *tag, const char *id)
Get the value associated with the specified tag on the RG line with the specified id,...
SamHeaderRG * getRG(const char *id)
Get the RG object with the specified read group identifier, returning NULL if there is no RG object w...
const char * getTagValue(const char *tag) const
Return the value associated with the specified tag.
Class providing an easy to use interface to get/set/operate on the fields in a SAM/BAM record.
Definition: SamRecord.h:52
int32_t getBlockSize()
Get the block size of the record (BAM format).
Definition: SamRecord.cpp:1281
uint16_t getCigarLength()
Get the length of the BAM formatted CIGAR.
Definition: SamRecord.cpp:1362
const char * getReferenceName()
Get the reference sequence name (RNAME) of the record.
Definition: SamRecord.cpp:1298
int32_t getInsertSize()
Get the inferred insert size of the read pair (ISIZE) or observed template length (TLEN).
Definition: SamRecord.cpp:1459
int32_t get0BasedMatePosition()
Get the 0-based(BAM) leftmost mate/next fragment's position.
Definition: SamRecord.cpp:1452
int32_t get1BasedPosition()
Get the 1-based(SAM) leftmost position (POS) of the record.
Definition: SamRecord.cpp:1312
int32_t getReferenceID()
Get the reference sequence id of the record (BAM format rid).
Definition: SamRecord.cpp:1305
int32_t getAlignmentLength()
Returns the length of the clipped sequence, returning 0 if the cigar is '*'.
Definition: SamRecord.cpp:1493
int & getInteger(const char *tag)
Get the integer value for the specified tag, DEPRECATED, use getIntegerTag that returns a bool.
Definition: SamRecord.cpp:2350
int32_t get1BasedAlignmentEnd()
Returns the 1-based inclusive rightmost position of the clipped sequence.
Definition: SamRecord.cpp:1486
uint8_t getReadNameLength()
Get the length of the readname (QNAME) including the null.
Definition: SamRecord.cpp:1326
bool getFloatTag(const char *tag, float &tagVal)
Get the float value for the specified tag.
Definition: SamRecord.cpp:2281
const char * getMateReferenceNameOrEqual()
Get the mate/next fragment's reference sequence name (RNEXT), returning "=" if it is the same as the ...
Definition: SamRecord.cpp:1420
int32_t get1BasedUnclippedStart()
Returns the 1-based inclusive left-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1519
uint16_t getBin()
Get the BAM bin for the record.
Definition: SamRecord.cpp:1347
int32_t getMateReferenceID()
Get the mate reference id of the record (BAM format: mate_rid/next_refID).
Definition: SamRecord.cpp:1438
bool getFields(bamRecordStruct &recStruct, String &readName, String &cigar, String &sequence, String &quality)
Returns the values of all fields except the tags.
Definition: SamRecord.cpp:1866
uint16_t getFlag()
Get the flag (FLAG).
Definition: SamRecord.cpp:1384
const void * getRecordBuffer()
Get a const pointer to the buffer that contains the BAM representation of the record.
Definition: SamRecord.cpp:1204
int32_t get1BasedMatePosition()
Get the 1-based(SAM) leftmost mate/next fragment's position (PNEXT).
Definition: SamRecord.cpp:1445
int32_t get0BasedUnclippedEnd()
Returns the 0-based inclusive right-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1526
const SamStatus & getStatus()
Returns the status associated with the last method that sets the status.
Definition: SamRecord.cpp:2403
int32_t get1BasedUnclippedEnd()
Returns the 1-based inclusive right-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1535
uint32_t getNumOverlaps(int32_t start, int32_t end)
Return the number of bases in this read that overlap the passed in region.
Definition: SamRecord.cpp:1853
const char * getMateReferenceName()
Get the mate/next fragment's reference sequence name (RNEXT).
Definition: SamRecord.cpp:1410
bool getNextSamTag(char *tag, char &vtype, void **value)
Get the next tag from the record.
Definition: SamRecord.cpp:1962
int32_t get0BasedUnclippedStart()
Returns the 0-based inclusive left-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1506
int32_t getReadLength()
Get the length of the read.
Definition: SamRecord.cpp:1391
int32_t get0BasedAlignmentEnd()
Returns the 0-based inclusive rightmost position of the clipped sequence.
Definition: SamRecord.cpp:1467
int32_t get0BasedPosition()
Get the 0-based(BAM) leftmost position of the record.
Definition: SamRecord.cpp:1319
const char * getCigar()
Returns the SAM formatted CIGAR string.
Definition: SamRecord.cpp:1555
uint8_t getMapQuality()
Get the mapping quality (MAPQ) of the record.
Definition: SamRecord.cpp:1340
const String & getString(const char *tag)
Get the string value for the specified tag.
Definition: SamRecord.cpp:2314
const char * getReadName()
Returns the SAM formatted Read Name (QNAME).
Definition: SamRecord.cpp:1542
const char * getQuality()
Returns the SAM formatted quality string (QUAL).
Definition: SamRecord.cpp:1638
const char * getSequence()
Returns the SAM formatted sequence string (SEQ), translating the base as specified by setSequenceTran...
Definition: SamRecord.cpp:1568
static const int NO_REF_ID
Constant for the value returned if a reference id does not exist for a queried reference name.
@ SUCCESS
method completed successfully.
Definition: StatGenStatus.h:32
Structure of a BAM record.
Definition: SamRecord.h:34