ReadFiles.cpp

00001 /*
00002  *  Copyright (C) 2010  Regents of the University of Michigan
00003  *
00004  *   This program is free software: you can redistribute it and/or modify
00005  *   it under the terms of the GNU General Public License as published by
00006  *   the Free Software Foundation, either version 3 of the License, or
00007  *   (at your option) any later version.
00008  *
00009  *   This program is distributed in the hope that it will be useful,
00010  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *   GNU General Public License for more details.
00013  *
00014  *   You should have received a copy of the GNU General Public License
00015  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 
00018 #include "ReadFiles.h"
00019 #include "Validate.h"
00020 #include <assert.h>
00021 
00022 void testReadSam()
00023 {
00024     SamFile inSam;
00025     assert(inSam.OpenForRead("testFiles/testSam.sam"));
00026 
00027     // Call generic test which since the sam and bam are identical, should
00028     // contain the same results.
00029     testRead(inSam);
00030 }
00031 
00032 void testReadBam()
00033 {
00034     SamFile inSam;
00035     assert(inSam.OpenForRead("testFiles/testBam.bam"));
00036 
00037     // Call generic test which since the sam and bam are identical, should
00038     // contain the same results.
00039     testRead(inSam);
00040 }
00041 
00042 void testRead(SamFile &inSam)
00043 {
00044     // Read the SAM Header.
00045     SamFileHeader samHeader;
00046     assert(inSam.ReadHeader(samHeader));
00047 
00048     validateHeader(samHeader);
00049     testModHeader(samHeader);
00050 
00051     SamRecord samRecord;
00052     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00053     validateRead1(samRecord);
00054 
00055     // Set a new quality and get the buffer.
00056     samRecord.setQuality("ABCDE");
00057     validateRead1ModQuality(samRecord);
00058     //   void* buffer = samRecord.getRecordBuffer();
00059 
00060     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00061     validateRead2(samRecord);
00062 
00063     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00064     validateRead3(samRecord);
00065 
00066     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00067     validateRead4(samRecord);
00068 
00069     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00070     validateRead5(samRecord);
00071 
00072     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00073     validateRead6(samRecord);
00074 
00075     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00076     validateRead7(samRecord);
00077 
00078     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00079     validateRead8(samRecord);
00080 
00081     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00082     validateRead9(samRecord);
00083 
00084     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00085     validateRead10(samRecord);
00086 }
00087 
00088 
00089 void testAddHeaderAndTagToFile(const char* inputName, const char* outputName)
00090 {
00091     SamFile inSam, outSam;
00092     assert(inSam.OpenForRead(inputName));
00093     assert(outSam.OpenForWrite(outputName));
00094 
00095     // Read the SAM Header.
00096     SamFileHeader samHeader;
00097     assert(inSam.ReadHeader(samHeader));
00098 
00099     // Add a header line.
00100     assert(samHeader.addHeaderLine("@RG\tID:myID\tSM:mySM") == false);
00101     assert(samHeader.addHeaderLine("@RG\tID:myID3\tSM:mySM") == true);
00102 
00103     // Write Header
00104     assert(outSam.WriteHeader(samHeader));
00105 
00106     SamRecord samRecord;
00107     assert(inSam.ReadRecord(samHeader, samRecord));
00108     //   validateRead1(samRecord);
00109     // Add two tags.
00110     assert(samRecord.addTag("RG", 'Z', "myID"));
00111     assert(samRecord.addTag("RR", 'Z', "myID"));
00112 
00113     // Write as Sam.
00114     assert(outSam.WriteRecord(samHeader, samRecord));
00115 
00116     // TODO, add test to verify it was written correctly.
00117 
00118     // Read a couple of records to make sure it properly can read them even
00119     // if they are bigger than the original.
00120     assert(inSam.ReadRecord(samHeader, samRecord));
00121     assert(inSam.ReadRecord(samHeader, samRecord));
00122 }
00123 
00124 
00125 // Test reading a file, validating it is sorted.
00126 void testValidateSortedRead()
00127 {
00128     // Open a file for reading.
00129     SamFile inSam(ErrorHandler::RETURN);
00130     assert(inSam.OpenForRead("testFiles/testSam.sam"));
00131 
00132     // Set the validation to COORDINATE.
00133     inSam.setSortedValidation(SamFile::COORDINATE);
00134 
00135     // Read the SAM Header.
00136     SamFileHeader samHeader;
00137     assert(inSam.ReadHeader(samHeader));
00138     
00139     SamRecord samRecord;
00140     // Succeed, first record.
00141     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00142     validateRead1(samRecord);
00143 
00144     // Succeed, higher coordinate.
00145     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00146     validateRead2(samRecord);
00147 
00148     // Failed sort order - due to coord.
00149     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00150     validateRead3(samRecord);
00151 
00152     // Failed sort order - due to coord.
00153     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00154     validateRead4(samRecord);
00155 
00156     // Succeed, new reference id
00157     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00158     validateRead5(samRecord);
00159 
00160     // Fail, previous reference id.
00161     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00162     validateRead6(samRecord);
00163 
00164     // Succeed, same reference id, higher coord.
00165     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00166     validateRead7(samRecord);
00167 
00168     // Succeed, *, new reference id.
00169     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00170     validateRead8(samRecord);
00171 
00172     // Fail, reference id is not *
00173     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00174     validateRead9(samRecord);
00175 
00176     // Succeed, valid reference id, and no coordinate.
00177     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00178     validateRead10(samRecord);
00179 
00180 
00181     ////////////////////////////////////////////
00182     // Reopen the file for reading
00183     assert(inSam.OpenForRead("testFiles/testSam.sam"));
00184 
00185     // Set the validation to QUERY_NAME.
00186     inSam.setSortedValidation(SamFile::QUERY_NAME);
00187 
00188     // Read the SAM Header.
00189     assert(inSam.ReadHeader(samHeader));
00190    
00191     // Succeed, first record.
00192     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00193     validateRead1(samRecord);
00194 
00195     // Succeed, same name.
00196     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00197     validateRead2(samRecord);
00198 
00199     // Failed sort order - due to alphabetical
00200     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00201     validateRead3(samRecord);
00202 
00203     // Failed sort order - due to alphabetical
00204     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00205     validateRead4(samRecord);
00206 
00207     // Failed sort order - due to alphabetical
00208     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00209     validateRead5(samRecord);
00210 
00211     // Failed sort order - due to alphabetical
00212     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00213     validateRead6(samRecord);
00214 
00215     // Failed sort order - due to alphabetical
00216     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00217     validateRead7(samRecord);
00218 
00219     // Succeed
00220     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00221     validateRead8(samRecord);
00222 
00223     // Failed sort order - due to alphabetical
00224     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00225     validateRead9(samRecord);
00226 
00227     // Succeed
00228     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00229     validateRead10(samRecord);
00230 
00231     ////////////////////////////////////////////
00232     // Reopen the file for reading
00233     assert(inSam.OpenForRead("testFiles/testSam.sam"));
00234 
00235     // Set the validation to the SO Flag.  Not set, so it is UNSORTED, so 
00236     // all reads should pass.
00237     inSam.setSortedValidation(SamFile::FLAG);
00238 
00239     // Read the SAM Header.
00240     assert(inSam.ReadHeader(samHeader));
00241    
00242     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00243     validateRead1(samRecord);
00244 
00245     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00246     validateRead2(samRecord);
00247 
00248     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00249     validateRead3(samRecord);
00250 
00251     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00252     validateRead4(samRecord);
00253 
00254     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00255     validateRead5(samRecord);
00256 
00257     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00258     validateRead6(samRecord);
00259 
00260     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00261     validateRead7(samRecord);
00262 
00263     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00264     validateRead8(samRecord);
00265 
00266     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00267     validateRead9(samRecord);
00268 
00269     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00270     validateRead10(samRecord);
00271 
00272     ////////////////////////////////////////////
00273     // Reopen for reading SO FLAG set to coordinate.
00274     assert(inSam.OpenForRead("testFiles/testSamSOcoord.sam"));
00275 
00276     // Set the validation to SO FLAG which is set to coordinate.
00277     inSam.setSortedValidation(SamFile::FLAG);
00278 
00279     // Read the SAM Header.
00280     assert(inSam.ReadHeader(samHeader));
00281 
00282     // Succeed, first record.
00283     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00284     validateRead1(samRecord);
00285 
00286     // Succeed, higher coordinate.
00287     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00288     validateRead2(samRecord);
00289 
00290     // Failed sort order - due to coord.
00291     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00292     validateRead3(samRecord);
00293 
00294     // Failed sort order - due to coord.
00295     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00296     validateRead4(samRecord);
00297 
00298     // Succeed, new reference id
00299     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00300     validateRead5(samRecord);
00301 
00302     // Fail, previous reference id.
00303     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00304     validateRead6(samRecord);
00305 
00306     // Succeed, same reference id, higher coord.
00307     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00308     validateRead7(samRecord);
00309 
00310     // Succeed, *, new reference id.
00311     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00312     validateRead8(samRecord);
00313 
00314     // Fail, reference id is not *
00315     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00316     validateRead9(samRecord);
00317 
00318     // Succeed, valid reference id, and no coordinate.
00319     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00320     validateRead10(samRecord);
00321 
00322 
00323     ////////////////////////////////////////////
00324     // Reopen the file for reading
00325     assert(inSam.OpenForRead("testFiles/testSamSOquery.sam"));
00326 
00327     // Set the validation to FLAG, SO set to queryname.
00328     inSam.setSortedValidation(SamFile::FLAG);
00329 
00330     // Read the SAM Header.
00331     assert(inSam.ReadHeader(samHeader));
00332    
00333     // Succeed, first record.
00334     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00335     validateRead1(samRecord);
00336 
00337     // Succeed, same name.
00338     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00339     validateRead2(samRecord);
00340 
00341     // Failed sort order - due to alphabetical
00342     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00343     validateRead3(samRecord);
00344 
00345     // Failed sort order - due to alphabetical
00346     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00347     validateRead4(samRecord);
00348 
00349     // Failed sort order - due to alphabetical
00350     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00351     validateRead5(samRecord);
00352 
00353     // Failed sort order - due to alphabetical
00354     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00355     validateRead6(samRecord);
00356 
00357     // Failed sort order - due to alphabetical
00358     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00359     validateRead7(samRecord);
00360 
00361     // Succeed
00362     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00363     validateRead8(samRecord);
00364 
00365     // Failed sort order - due to alphabetical
00366     assert(inSam.ReadRecord(samHeader, samRecord) == false);
00367     validateRead9(samRecord);
00368 
00369     // Succeed
00370     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00371     validateRead10(samRecord);
00372 
00373     ////////////////////////////////////////////
00374     // Reopen the file for reading, SO flag set to junk.
00375     assert(inSam.OpenForRead("testFiles/testSamSOinvalid.sam"));
00376 
00377     // Set the validation to the SO Flag.  Not set to anything valid,
00378     // so it is considered UNSORTED, so all reads should pass.
00379     inSam.setSortedValidation(SamFile::FLAG);
00380 
00381     // Read the SAM Header.
00382     assert(inSam.ReadHeader(samHeader));
00383    
00384     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00385     validateRead1(samRecord);
00386 
00387     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00388     validateRead2(samRecord);
00389 
00390     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00391     validateRead3(samRecord);
00392 
00393     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00394     validateRead4(samRecord);
00395 
00396     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00397     validateRead5(samRecord);
00398 
00399     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00400     validateRead6(samRecord);
00401 
00402     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00403     validateRead7(samRecord);
00404 
00405     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00406     validateRead8(samRecord);
00407 
00408     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00409     validateRead9(samRecord);
00410 
00411     assert(inSam.ReadRecord(samHeader, samRecord) == true);
00412     validateRead10(samRecord);
00413 }
00414 
00415 
00416 
00417 void validateRead1ModQuality(SamRecord& samRecord)
00418 {
00419     //////////////////////////////////////////
00420     // Validate Record 1
00421     // Create record structure for validating.
00422     int expectedBlockSize = 89;
00423     const char* expectedReferenceName = "1";
00424     const char* expectedMateReferenceName = "1";
00425     const char* expectedMateReferenceNameOrEqual = "=";
00426 
00427     bamRecordStruct* expectedRecordPtr =
00428         (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
00429 
00430     char tag[3];
00431     char type;
00432     void* value;
00433     bamRecordStruct* bufferPtr;
00434     unsigned char* varPtr;
00435 
00436     expectedRecordPtr->myBlockSize = expectedBlockSize;
00437     expectedRecordPtr->myReferenceID = 0;
00438     expectedRecordPtr->myPosition = 1010;
00439     expectedRecordPtr->myReadNameLength = 23;
00440     expectedRecordPtr->myMapQuality = 0;
00441     expectedRecordPtr->myBin = 4681;
00442     expectedRecordPtr->myCigarLength = 2;
00443     expectedRecordPtr->myFlag = 73;
00444     expectedRecordPtr->myReadLength = 5;
00445     expectedRecordPtr->myMateReferenceID = 0;
00446     expectedRecordPtr->myMatePosition = 1010;
00447     expectedRecordPtr->myInsertSize = 0;
00448    
00449     // Check the alignment end
00450     assert(samRecord.get0BasedAlignmentEnd() == 1016);
00451     assert(samRecord.get1BasedAlignmentEnd() == 1017);
00452     assert(samRecord.getAlignmentLength() == 7);
00453     assert(samRecord.get0BasedUnclippedStart() == 1010);
00454     assert(samRecord.get1BasedUnclippedStart() == 1011);
00455     assert(samRecord.get0BasedUnclippedEnd() == 1016);
00456     assert(samRecord.get1BasedUnclippedEnd() == 1017);
00457 
00458     // Check the accessors.
00459     assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
00460     assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
00461     assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
00462     assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
00463     assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
00464     assert(samRecord.getReadNameLength() == 
00465            expectedRecordPtr->myReadNameLength);
00466     assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
00467     assert(samRecord.getBin() == expectedRecordPtr->myBin);
00468     assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
00469     assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
00470     assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
00471     assert(samRecord.getMateReferenceID() ==
00472            expectedRecordPtr->myMateReferenceID);
00473     assert(strcmp(samRecord.getMateReferenceName(), 
00474                   expectedMateReferenceName) == 0);
00475     assert(strcmp(samRecord.getMateReferenceNameOrEqual(), 
00476                   expectedMateReferenceNameOrEqual) == 0);
00477     assert(samRecord.get1BasedMatePosition() == 
00478            expectedRecordPtr->myMatePosition + 1);
00479     assert(samRecord.get0BasedMatePosition() ==
00480            expectedRecordPtr->myMatePosition);
00481     assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
00482     assert(strcmp(samRecord.getReadName(), "1:1011:F:255+17M15D20M") == 0);
00483     assert(strcmp(samRecord.getCigar(), "5M2D") == 0);
00484     assert(strcmp(samRecord.getSequence(), "CCGAA") == 0);
00485     assert(strcmp(samRecord.getQuality(), "ABCDE") == 0);
00486     assert(samRecord.getNumOverlaps(1010, 1017) == 5);
00487     assert(samRecord.getNumOverlaps(1010, 1016) == 5);
00488     assert(samRecord.getNumOverlaps(1012, 1017) == 3);
00489     assert(samRecord.getNumOverlaps(1015, 1017) == 0);
00490     assert(samRecord.getNumOverlaps(1017, 1010) == 0);
00491     assert(samRecord.getNumOverlaps(1013, 1011) == 0);
00492     assert(samRecord.getNumOverlaps(-1, 1017) == 5);
00493 
00494     // Reset the tag iter, since the tags have already been read.
00495     samRecord.resetTagIter();
00496 
00497     // Check the tags.
00498     assert(samRecord.getNextSamTag(tag, type, &value) == true);
00499     assert(tag[0] == 'A');
00500     assert(tag[1] == 'M');
00501     assert(type == 'i');
00502     assert(*(char*)value == 0);
00503     assert(samRecord.getNextSamTag(tag, type, &value) == true);
00504     assert(tag[0] == 'M');
00505     assert(tag[1] == 'D');
00506     assert(type == 'Z');
00507     assert(*(String*)value == "37");
00508     assert(samRecord.getNextSamTag(tag, type, &value) == true);
00509     assert(tag[0] == 'N');
00510     assert(tag[1] == 'M');
00511     assert(type == 'i');
00512     assert(*(char*)value == 0);
00513     assert(samRecord.getNextSamTag(tag, type, &value) == true);
00514     assert(tag[0] == 'X');
00515     assert(tag[1] == 'T');
00516     assert(type == 'A');
00517     assert(*(char*)value == 'R');
00518     // No more tags, should return false.
00519     assert(samRecord.getNextSamTag(tag, type, &value) == false);
00520     assert(samRecord.getNextSamTag(tag, type, &value) == false);
00521 
00522     // Get the record ptr.   
00523     bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
00524     // Validate the buffers match.
00525     assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
00526     assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
00527     assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
00528     assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
00529     assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
00530     assert(bufferPtr->myBin == expectedRecordPtr->myBin);
00531     assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
00532     assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
00533     assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
00534     assert(bufferPtr->myMateReferenceID ==
00535            expectedRecordPtr->myMateReferenceID);
00536     assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
00537     assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
00538 
00539     // Validate the variable length fields in the buffer.
00540     // Set the pointer to the start of the variable fields.
00541     varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
00542 
00543     // Validate the readname.
00544     for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
00545     {
00546         assert(*varPtr == samRecord.getReadName()[i]);
00547         varPtr++;
00548     }
00549 
00550     // Validate the cigar.
00551     // The First cigar is 5M which is 5 << 4 | 0 = 80
00552     assert(*(unsigned int*)varPtr == 80);
00553     // Increment the varptr the size of an int.
00554     varPtr += 4;
00555     // The 2nd cigar is 2D which is 2 << 4 | 2 = 34
00556     assert(*(unsigned int*)varPtr == 34);
00557     // Increment the varptr the size of an int.
00558     varPtr += 4;
00559    
00560     // Validate the sequence.
00561     // CC = 0x22
00562     assert(*varPtr == 0x22);
00563     varPtr++;
00564     // GA = 0x41
00565     assert(*varPtr == 0x41);
00566     varPtr++;
00567     // A  = 0x10
00568     assert(*varPtr == 0x10);
00569     varPtr++;
00570   
00571     // Validate the Quality
00572     for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
00573     {
00574         assert(*varPtr == samRecord.getQuality()[i] - 33);
00575         varPtr++;
00576     }
00577 
00578     // Validate the tags.  
00579     assert(*varPtr == 'A');
00580     varPtr++;
00581     assert(*varPtr == 'M');
00582     varPtr++;
00583     assert(*varPtr == 'C');
00584     varPtr++;
00585     assert(*varPtr == 0);
00586     varPtr++;
00587     assert(*varPtr == 'M');
00588     varPtr++;
00589     assert(*varPtr == 'D');
00590     varPtr++;
00591     assert(*varPtr == 'Z');
00592     varPtr++;
00593     assert(*varPtr == '3');
00594     varPtr++;
00595     assert(*varPtr == '7');
00596     varPtr++;
00597     assert(*varPtr == 0);
00598     varPtr++;
00599     assert(*varPtr == 'N');
00600     varPtr++;
00601     assert(*varPtr == 'M');
00602     varPtr++;
00603     assert(*varPtr == 'C');
00604     varPtr++;
00605     assert(*varPtr == 0);
00606     varPtr++;
00607     assert(*varPtr == 'X');
00608     varPtr++;
00609     assert(*varPtr == 'T');
00610     varPtr++;
00611     assert(*varPtr == 'A');
00612     varPtr++;
00613     assert(*varPtr == 'R');
00614     varPtr++;
00615 }
00616 
00617 
00618 void testModHeader(SamFileHeader& samHeader)
00619 {
00620     // Check the header line.
00621     std::string headerString = "";
00622     assert(samHeader.getHeaderString(headerString) == true);
00623     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");
00624 
00625     // Remove a tag - by setting it to "".
00626     assert(samHeader.setRGTag("LB", "", "myID2") == true);
00627 
00628 
00629     // Check the header line.
00630     assert(samHeader.getHeaderString(headerString) == true);
00631     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\n@CO\tComment 1\n@CO\tComment 2\n");
00632 
00633     //  Add an HD tag.
00634     SamHeaderHD* hd = new SamHeaderHD();
00635     assert(hd->setTag("VN", "1.3") == true);
00636     assert(samHeader.addHD(hd) == true);
00637     assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") == 0);
00638     assert(samHeader.getHeaderString(headerString) == true);
00639     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\n@HD\tVN:1.3\n@CO\tComment 1\n@CO\tComment 2\n");
00640 
00641     // Try adding another HD tag.
00642     SamHeaderHD* hd2 = new SamHeaderHD();
00643     assert(hd2->setTag("VN", "1.4") == true);
00644     assert(samHeader.addHD(hd2) == false);
00645     assert(strcmp(samHeader.getHDTagValue("VN"), "1.4") != 0);
00646     assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") == 0);
00647     assert(samHeader.getHeaderString(headerString) == true);
00648     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\n@HD\tVN:1.3\n@CO\tComment 1\n@CO\tComment 2\n");
00649 
00650     // Remove the entire HD Tag.
00651     assert(samHeader.removeHD() == true);
00652     assert(strcmp(samHeader.getHDTagValue("VN"), "") == 0);
00653     assert(samHeader.getHeaderString(headerString) == true);
00654     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\n@CO\tComment 1\n@CO\tComment 2\n");
00655 
00656     // Remove an entire SQ Tag.
00657     assert(strcmp(samHeader.getSQTagValue("LN", "11"), "134452384") == 0);
00658     assert(samHeader.removeSQ("11") == true);
00659     assert(strcmp(samHeader.getSQTagValue("LN", "11"), "") == 0);
00660     assert(samHeader.getHeaderString(headerString) == true);
00661     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: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\n@CO\tComment 1\n@CO\tComment 2\n");
00662 
00663     // Try adding a null HD tag.
00664     hd = NULL;
00665     assert(samHeader.addHD(hd) == false);
00666     assert(strcmp(samHeader.getHDTagValue("VN"), "") == 0);
00667     assert(strcmp(samHeader.getHDTagValue("VN"), "1.4") != 0);
00668     assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") != 0);
00669     assert(samHeader.getHeaderString(headerString) == true);
00670     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: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\n@CO\tComment 1\n@CO\tComment 2\n");
00671 
00672     // Try adding a null SQ tag.
00673     SamHeaderSQ* sq = NULL;
00674     assert(samHeader.addSQ(sq) == false);
00675     assert(samHeader.getHeaderString(headerString) == true);
00676     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: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\n@CO\tComment 1\n@CO\tComment 2\n");
00677 
00678     // Try adding an HD tag again.
00679     assert(samHeader.addHD(hd2) == true);
00680     assert(strcmp(samHeader.getHDTagValue("VN"), "1.4") == 0);
00681     assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") != 0);
00682     assert(samHeader.getHeaderString(headerString) == true);
00683     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: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\n@HD\tVN:1.4\n@CO\tComment 1\n@CO\tComment 2\n");
00684 
00685 
00686     // TODO Get the comments.
00687 
00688 }