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 
21 const std::string TestValidate::READ1_CIGAR = "5M2D";
22 const std::string TestValidate::READ1_SEQ = "CCGAA";
23 const std::string TestValidate::READ1_QUAL = "6>6+4";
24 
25 const std::string TestValidate::READ6_CIGAR = "3S2H5M";
26 const std::string TestValidate::READ6_SEQ = "TGCACGTN";
27 const std::string TestValidate::READ6_QUAL = "453;>>>>";
28 
29 const std::string TestValidate::READ7_CIGAR = "3S5M1S3H";
30 const std::string TestValidate::READ7_SEQ = "TGCACGTNG";
31 const std::string TestValidate::READ7_QUAL = "453;>>>>5";
32 
33 void 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 
295 void 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 
499 void 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 
701 void 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 
897 void 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 
1146 void 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 
1292 void 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 
1445 void 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 
1575 void 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 
1724 void 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 
1840 void validateHeader(SamFileHeader& samHeader)
1841 {
1842  validateHeaderFields(samHeader);
1843  validateHeaderString(samHeader);
1844 }
1845 
1846 
1847 void 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 
1941 void 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
uint8_t getMapQuality()
Get the mapping quality (MAPQ) of the record.
Definition: SamRecord.cpp:1328
int32_t get0BasedUnclippedStart()
Returns the 0-based inclusive left-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1494
int32_t get0BasedAlignmentEnd()
Returns the 0-based inclusive rightmost position of the clipped sequence.
Definition: SamRecord.cpp:1455
SamHeaderRG * getRG(const char *id)
Get the RG object with the specified read group identifier, returning NULL if there is no RG object w...
bool getNextSamTag(char *tag, char &vtype, void **value)
Get the next tag from the record.
Definition: SamRecord.cpp:1950
uint16_t getCigarLength()
Get the length of the BAM formatted CIGAR.
Definition: SamRecord.cpp:1350
int32_t get0BasedMatePosition()
Get the 0-based(BAM) leftmost mate/next fragment&#39;s position.
Definition: SamRecord.cpp:1440
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 getFloatTag(const char *tag, float &tagVal)
Get the float value for the specified tag.
Definition: SamRecord.cpp:2269
int32_t get1BasedAlignmentEnd()
Returns the 1-based inclusive rightmost position of the clipped sequence.
Definition: SamRecord.cpp:1474
bool getFields(bamRecordStruct &recStruct, String &readName, String &cigar, String &sequence, String &quality)
Returns the values of all fields except the tags.
Definition: SamRecord.cpp:1854
int32_t get0BasedUnclippedEnd()
Returns the 0-based inclusive right-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1514
static const int NO_REF_ID
Constant for the value returned if a reference id does not exist for a queried reference name...
int & getInteger(const char *tag)
Get the integer value for the specified tag, DEPRECATED, use getIntegerTag that returns a bool...
Definition: SamRecord.cpp:2338
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 * getTagValue(const char *tag) const
Return the value associated with the specified tag.
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:1841
const char * getReadName()
Returns the SAM formatted Read Name (QNAME).
Definition: SamRecord.cpp:1530
const char * getHDTagValue(const char *tag)
Returns the value associated with the specified HD tag, returning "" if the tag does not exist in the...
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...
int32_t get1BasedUnclippedEnd()
Returns the 1-based inclusive right-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1523
int32_t getReferenceID()
Get the reference sequence id of the record (BAM format rid).
Definition: SamRecord.cpp:1293
method completed successfully.
Definition: StatGenStatus.h:32
uint16_t getBin()
Get the BAM bin for the record.
Definition: SamRecord.cpp:1335
const char * getMateReferenceNameOrEqual()
Get the mate/next fragment&#39;s reference sequence name (RNEXT), returning "=" if it is the same as the ...
Definition: SamRecord.cpp:1408
int32_t getAlignmentLength()
Returns the length of the clipped sequence, returning 0 if the cigar is &#39;*&#39;.
Definition: SamRecord.cpp:1481
int32_t get1BasedUnclippedStart()
Returns the 1-based inclusive left-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1507
const char * getSequence()
Returns the SAM formatted sequence string (SEQ), translating the base as specified by setSequenceTran...
Definition: SamRecord.cpp:1556
int32_t getReadLength()
Get the length of the read.
Definition: SamRecord.cpp:1379
Structure of a BAM record.
Definition: SamRecord.h:33
uint8_t getReadNameLength()
Get the length of the readname (QNAME) including the null.
Definition: SamRecord.cpp:1314
bool getHeaderString(std::string &header) const
Set the passed in string to the entire header string, clearing its current contents.
int32_t get1BasedPosition()
Get the 1-based(SAM) leftmost position (POS) of the record.
Definition: SamRecord.cpp:1300
const void * getRecordBuffer()
Get a const pointer to the buffer that contains the BAM representation of the record.
Definition: SamRecord.cpp:1192
const SamStatus & getStatus()
Returns the status associated with the last method that sets the status.
Definition: SamRecord.cpp:2391
const char * getQuality()
Returns the SAM formatted quality string (QUAL).
Definition: SamRecord.cpp:1626
This class allows a user to get/set the fields in a SAM/BAM Header.
Definition: SamFileHeader.h:34
const String & getString(const char *tag)
Get the string value for the specified tag.
Definition: SamRecord.cpp:2302
int32_t getBlockSize()
Get the block size of the record (BAM format).
Definition: SamRecord.cpp:1269
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...
int32_t getMateReferenceID()
Get the mate reference id of the record (BAM format: mate_rid/next_refID).
Definition: SamRecord.cpp:1426
const char * getMateReferenceName()
Get the mate/next fragment&#39;s reference sequence name (RNEXT).
Definition: SamRecord.cpp:1398
Class providing an easy to use interface to get/set/operate on the fields in a SAM/BAM record...
Definition: SamRecord.h:51
int32_t get1BasedMatePosition()
Get the 1-based(SAM) leftmost mate/next fragment&#39;s position (PNEXT).
Definition: SamRecord.cpp:1433
uint16_t getFlag()
Get the flag (FLAG).
Definition: SamRecord.cpp:1372
int32_t getInsertSize()
Get the inferred insert size of the read pair (ISIZE) or observed template length (TLEN)...
Definition: SamRecord.cpp:1447
int getReferenceID(const String &referenceName, bool addID=false)
Get the reference ID for the specified reference name (chromosome).
int32_t get0BasedPosition()
Get the 0-based(BAM) leftmost position of the record.
Definition: SamRecord.cpp:1307
const char * getCigar()
Returns the SAM formatted CIGAR string.
Definition: SamRecord.cpp:1543
const char * getReferenceName()
Get the reference sequence name (RNAME) of the record.
Definition: SamRecord.cpp:1286