00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "Validate.h"
00019 #include "BaseUtilities.h"
00020
00021 void validateRead1(SamRecord& samRecord)
00022 {
00023
00024
00025
00026 int expectedBlockSize = 89;
00027 const char* expectedReferenceName = "1";
00028 const char* expectedMateReferenceName = "1";
00029 const char* expectedMateReferenceNameOrEqual = "=";
00030
00031 bamRecordStruct* expectedRecordPtr =
00032 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
00033
00034 char tag[3];
00035 char type;
00036 void* value;
00037 const bamRecordStruct* bufferPtr;
00038 unsigned char* varPtr;
00039
00040 expectedRecordPtr->myBlockSize = expectedBlockSize;
00041 expectedRecordPtr->myReferenceID = 0;
00042 expectedRecordPtr->myPosition = 1010;
00043 expectedRecordPtr->myReadNameLength = 23;
00044 expectedRecordPtr->myMapQuality = 0;
00045 expectedRecordPtr->myBin = 4681;
00046 expectedRecordPtr->myCigarLength = 2;
00047 expectedRecordPtr->myFlag = 73;
00048 expectedRecordPtr->myReadLength = 5;
00049 expectedRecordPtr->myMateReferenceID = 0;
00050 expectedRecordPtr->myMatePosition = 1010;
00051 expectedRecordPtr->myInsertSize = 0;
00052
00053 assert(samRecord.getString("MD") == "37");
00054 assert(samRecord.getString("YZ") == "");
00055 assert(samRecord.getInteger("YZ") == -1);
00056 assert(samRecord.getDouble("YZ") == -1);
00057
00058 assert(samRecord.get0BasedAlignmentEnd() == 1016);
00059 assert(samRecord.get1BasedAlignmentEnd() == 1017);
00060 assert(samRecord.getAlignmentLength() == 7);
00061 assert(samRecord.get0BasedUnclippedStart() == 1010);
00062 assert(samRecord.get1BasedUnclippedStart() == 1011);
00063 assert(samRecord.get0BasedUnclippedEnd() == 1016);
00064 assert(samRecord.get1BasedUnclippedEnd() == 1017);
00065
00066
00067 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
00068 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
00069 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
00070 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
00071 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
00072 assert(samRecord.getReadNameLength() ==
00073 expectedRecordPtr->myReadNameLength);
00074 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
00075 assert(samRecord.getBin() == expectedRecordPtr->myBin);
00076 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
00077 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
00078 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
00079 assert(samRecord.getMateReferenceID() ==
00080 expectedRecordPtr->myMateReferenceID);
00081 assert(strcmp(samRecord.getMateReferenceName(),
00082 expectedMateReferenceName) == 0);
00083 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
00084 expectedMateReferenceNameOrEqual) == 0);
00085 assert(samRecord.get1BasedMatePosition() ==
00086 expectedRecordPtr->myMatePosition + 1);
00087 assert(samRecord.get0BasedMatePosition() ==
00088 expectedRecordPtr->myMatePosition);
00089 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
00090 assert(strcmp(samRecord.getReadName(), "1:1011:F:255+17M15D20M") == 0);
00091 assert(strcmp(samRecord.getCigar(), "5M2D") == 0);
00092 assert(strcmp(samRecord.getSequence(), "CCGAA") == 0);
00093 assert(strcmp(samRecord.getQuality(), "6>6+4") == 0);
00094
00095 assert(samRecord.getSequence(0) == 'C');
00096 assert(samRecord.getQuality(0) == '6');
00097 assert(samRecord.getSequence(1) == 'C');
00098 assert(samRecord.getQuality(1) == '>');
00099 assert(samRecord.getSequence(2) == 'G');
00100 assert(samRecord.getQuality(2) == '6');
00101 assert(samRecord.getSequence(3) == 'A');
00102 assert(samRecord.getQuality(3) == '+');
00103 assert(samRecord.getSequence(4) == 'A');
00104 assert(samRecord.getQuality(4) == '4');
00105
00106 bool caught = false;
00107 try
00108 {
00109 samRecord.getSequence(-1);
00110 }
00111 catch (std::exception& e)
00112 {
00113 caught = true;
00114 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is out of range. Index must be between 0 and 4") == 0);
00115 }
00116 assert(caught == true);
00117 caught = false;
00118 try
00119 {
00120 samRecord.getQuality(-1);
00121 }
00122 catch (std::exception& e)
00123 {
00124 caught = true;
00125 assert(strcmp(e.what(), "SamRecord::getQuality(-1) is out of range. Index must be between 0 and 4") == 0);
00126 }
00127 assert(caught == true);
00128
00129 caught = false;
00130 try
00131 {
00132 samRecord.getSequence(5);
00133 }
00134 catch (std::exception& e)
00135 {
00136 caught = true;
00137 assert(strcmp(e.what(), "SamRecord::getSequence(5) is out of range. Index must be between 0 and 4") == 0);
00138 }
00139 assert(caught == true);
00140 caught = false;
00141 try
00142 {
00143 samRecord.getQuality(5);
00144 }
00145 catch (std::exception& e)
00146 {
00147 caught = true;
00148 assert(strcmp(e.what(), "SamRecord::getQuality(5) is out of range. Index must be between 0 and 4") == 0);
00149 }
00150 assert(caught == true);
00151
00152 assert(samRecord.getNumOverlaps(1010, 1017) == 5);
00153 assert(samRecord.getNumOverlaps(1010, 1016) == 5);
00154 assert(samRecord.getNumOverlaps(1012, 1017) == 3);
00155 assert(samRecord.getNumOverlaps(1015, 1017) == 0);
00156 assert(samRecord.getNumOverlaps(1017, 1010) == 0);
00157 assert(samRecord.getNumOverlaps(1013, 1011) == 0);
00158 assert(samRecord.getNumOverlaps(-1, 1017) == 5);
00159 assert(samRecord.getNumOverlaps(1010, -1) == 5);
00160
00161
00162 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00163 assert(tag[0] == 'A');
00164 assert(tag[1] == 'M');
00165 assert(type == 'i');
00166 assert(*(char*)value == 0);
00167 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00168 assert(tag[0] == 'M');
00169 assert(tag[1] == 'D');
00170 assert(type == 'Z');
00171 assert(*(String*)value == "37");
00172 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00173 assert(tag[0] == 'N');
00174 assert(tag[1] == 'M');
00175 assert(type == 'i');
00176 assert(*(char*)value == 0);
00177 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00178 assert(tag[0] == 'X');
00179 assert(tag[1] == 'T');
00180 assert(type == 'A');
00181 assert(*(char*)value == 'R');
00182
00183 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00184 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00185
00186
00187 bufferPtr = (const bamRecordStruct*)samRecord.getRecordBuffer();
00188
00189 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
00190 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
00191 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
00192 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
00193 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
00194 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
00195 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
00196 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
00197 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
00198 assert(bufferPtr->myMateReferenceID ==
00199 expectedRecordPtr->myMateReferenceID);
00200 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
00201 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
00202
00203
00204
00205 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
00206
00207
00208 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
00209 {
00210 assert(*varPtr == samRecord.getReadName()[i]);
00211 varPtr++;
00212 }
00213
00214
00215
00216 assert(*(unsigned int*)varPtr == 80);
00217
00218 varPtr += 4;
00219
00220 assert(*(unsigned int*)varPtr == 34);
00221
00222 varPtr += 4;
00223
00224
00225
00226 assert(*varPtr == 0x22);
00227 varPtr++;
00228
00229 assert(*varPtr == 0x41);
00230 varPtr++;
00231
00232 assert(*varPtr == 0x10);
00233 varPtr++;
00234
00235
00236 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
00237 {
00238 assert(*varPtr == samRecord.getQuality()[i] - 33);
00239 varPtr++;
00240 }
00241
00242
00243 assert(*varPtr == 'A');
00244 varPtr++;
00245 assert(*varPtr == 'M');
00246 varPtr++;
00247 assert(*varPtr == 'C');
00248 varPtr++;
00249 assert(*varPtr == 0);
00250 varPtr++;
00251 assert(*varPtr == 'M');
00252 varPtr++;
00253 assert(*varPtr == 'D');
00254 varPtr++;
00255 assert(*varPtr == 'Z');
00256 varPtr++;
00257 assert(*varPtr == '3');
00258 varPtr++;
00259 assert(*varPtr == '7');
00260 varPtr++;
00261 assert(*varPtr == 0);
00262 varPtr++;
00263 assert(*varPtr == 'N');
00264 varPtr++;
00265 assert(*varPtr == 'M');
00266 varPtr++;
00267 assert(*varPtr == 'C');
00268 varPtr++;
00269 assert(*varPtr == 0);
00270 varPtr++;
00271 assert(*varPtr == 'X');
00272 varPtr++;
00273 assert(*varPtr == 'T');
00274 varPtr++;
00275 assert(*varPtr == 'A');
00276 varPtr++;
00277 assert(*varPtr == 'R');
00278 varPtr++;
00279 }
00280
00281
00282 void validateRead2(SamRecord& samRecord)
00283 {
00284
00285
00286
00287 int expectedBlockSize = 61;
00288 const char* expectedReferenceName = "1";
00289 const char* expectedMateReferenceName = "1";
00290 const char* expectedMateReferenceNameOrEqual = "=";
00291
00292 bamRecordStruct* expectedRecordPtr =
00293 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
00294
00295 char tag[3];
00296 char type;
00297 void* value;
00298 bamRecordStruct* bufferPtr;
00299 unsigned char* varPtr;
00300
00301 expectedRecordPtr->myBlockSize = expectedBlockSize;
00302 expectedRecordPtr->myReferenceID = 0;
00303 expectedRecordPtr->myPosition = 1011;
00304 expectedRecordPtr->myReadNameLength = 23;
00305 expectedRecordPtr->myMapQuality = 0;
00306 expectedRecordPtr->myBin = 4681;
00307 expectedRecordPtr->myCigarLength = 0;
00308 expectedRecordPtr->myFlag = 133;
00309 expectedRecordPtr->myReadLength = 4;
00310 expectedRecordPtr->myMateReferenceID = 0;
00311 expectedRecordPtr->myMatePosition = 1010;
00312 expectedRecordPtr->myInsertSize = 0;
00313
00314
00315 bamRecordStruct retrieveRecord;
00316 String retrieveReadName;
00317 String retrieveCigar;
00318 String retrieveSequence;
00319 String retrieveQuality;
00320
00321 assert(samRecord.getFields(retrieveRecord, retrieveReadName,
00322 retrieveCigar, retrieveSequence,
00323 retrieveQuality) == true);
00324 assert(retrieveRecord.myBlockSize == expectedRecordPtr->myBlockSize);
00325 assert(retrieveRecord.myReferenceID == expectedRecordPtr->myReferenceID);
00326 assert(retrieveRecord.myPosition == expectedRecordPtr->myPosition);
00327 assert(retrieveRecord.myReadNameLength ==
00328 expectedRecordPtr->myReadNameLength);
00329 assert(retrieveRecord.myMapQuality == expectedRecordPtr->myMapQuality);
00330 assert(retrieveRecord.myBin == expectedRecordPtr->myBin);
00331 assert(retrieveRecord.myCigarLength == expectedRecordPtr->myCigarLength);
00332 assert(retrieveRecord.myFlag == expectedRecordPtr->myFlag);
00333 assert(retrieveRecord.myReadLength == expectedRecordPtr->myReadLength);
00334 assert(retrieveRecord.myMateReferenceID ==
00335 expectedRecordPtr->myMateReferenceID);
00336 assert(retrieveRecord.myMatePosition == expectedRecordPtr->myMatePosition);
00337 assert(retrieveRecord.myInsertSize == expectedRecordPtr->myInsertSize);
00338
00339
00340 assert(samRecord.getAlignmentLength() == 0);
00341 assert(samRecord.get0BasedAlignmentEnd() == 1011);
00342 assert(samRecord.get1BasedAlignmentEnd() == 1012);
00343 assert(samRecord.get0BasedUnclippedStart() == 1011);
00344 assert(samRecord.get1BasedUnclippedStart() == 1012);
00345 assert(samRecord.get0BasedUnclippedEnd() == 1011);
00346 assert(samRecord.get1BasedUnclippedEnd() == 1012);
00347
00348
00349 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
00350 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
00351 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
00352 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
00353 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
00354 assert(samRecord.getReadNameLength() ==
00355 expectedRecordPtr->myReadNameLength);
00356 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
00357 assert(samRecord.getBin() == expectedRecordPtr->myBin);
00358 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
00359 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
00360 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
00361 assert(samRecord.getMateReferenceID() ==
00362 expectedRecordPtr->myMateReferenceID);
00363 assert(strcmp(samRecord.getMateReferenceName(),
00364 expectedMateReferenceName) == 0);
00365 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
00366 expectedMateReferenceNameOrEqual) == 0);
00367 assert(samRecord.get1BasedMatePosition() ==
00368 expectedRecordPtr->myMatePosition + 1);
00369 assert(samRecord.get0BasedMatePosition() ==
00370 expectedRecordPtr->myMatePosition);
00371 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
00372 assert(strcmp(samRecord.getReadName(), "1:1011:F:255+17M15D20M") == 0);
00373 assert(strcmp(samRecord.getCigar(), "*") == 0);
00374 assert(strcmp(samRecord.getSequence(), "CTGT") == 0);
00375 assert(strcmp(samRecord.getQuality(), ">>9>") == 0);
00376
00377 assert(samRecord.getSequence(0) == 'C');
00378 assert(samRecord.getQuality(0) == '>');
00379 assert(samRecord.getSequence(1) == 'T');
00380 assert(samRecord.getQuality(1) == '>');
00381 assert(samRecord.getSequence(2) == 'G');
00382 assert(samRecord.getQuality(2) == '9');
00383 assert(samRecord.getSequence(3) == 'T');
00384 assert(samRecord.getQuality(3) == '>');
00385 bool caught = false;
00386 try
00387 {
00388 samRecord.getSequence(-1);
00389 }
00390 catch (std::exception& e)
00391 {
00392 caught = true;
00393 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is out of range. Index must be between 0 and 3") == 0);
00394 }
00395 assert(caught == true);
00396 caught = false;
00397 try
00398 {
00399 samRecord.getQuality(-1);
00400 }
00401 catch (std::exception& e)
00402 {
00403 caught = true;
00404 assert(strcmp(e.what(), "SamRecord::getQuality(-1) is out of range. Index must be between 0 and 3") == 0);
00405 }
00406 assert(caught == true);
00407
00408 caught = false;
00409 try
00410 {
00411 samRecord.getSequence(4);
00412 }
00413 catch (std::exception& e)
00414 {
00415 caught = true;
00416 assert(strcmp(e.what(), "SamRecord::getSequence(4) is out of range. Index must be between 0 and 3") == 0);
00417 }
00418 assert(caught == true);
00419 caught = false;
00420 try
00421 {
00422 samRecord.getQuality(4);
00423 }
00424 catch (std::exception& e)
00425 {
00426 caught = true;
00427 assert(strcmp(e.what(), "SamRecord::getQuality(4) is out of range. Index must be between 0 and 3") == 0);
00428 }
00429 assert(caught == true);
00430
00431 assert(samRecord.getNumOverlaps(1011, 1017) == 0);
00432 assert(samRecord.getNumOverlaps(0, 1116) == 0);
00433
00434
00435 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00436 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00437
00438
00439 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
00440
00441 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
00442 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
00443 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
00444 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
00445 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
00446 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
00447 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
00448 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
00449 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
00450 assert(bufferPtr->myMateReferenceID ==
00451 expectedRecordPtr->myMateReferenceID);
00452 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
00453 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
00454
00455
00456
00457 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
00458
00459
00460 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
00461 {
00462 assert(*varPtr == samRecord.getReadName()[i]);
00463 varPtr++;
00464 }
00465
00466
00467
00468
00469 assert(*varPtr == 0x28);
00470 varPtr++;
00471
00472 assert(*varPtr == 0x48);
00473 varPtr++;
00474
00475
00476 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
00477 {
00478 assert(*varPtr == samRecord.getQuality()[i] - 33);
00479 varPtr++;
00480 }
00481
00482
00483 }
00484
00485
00486 void validateRead3(SamRecord& samRecord)
00487 {
00488
00489
00490
00491 int expectedBlockSize = 87;
00492 const char* expectedReferenceName = "1";
00493 const char* expectedMateReferenceName = "18";
00494 const char* expectedMateReferenceNameOrEqual = "18";
00495
00496 bamRecordStruct* expectedRecordPtr =
00497 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
00498
00499 char tag[3];
00500 char type;
00501 void* value;
00502 bamRecordStruct* bufferPtr;
00503 unsigned char* varPtr;
00504
00505 expectedRecordPtr->myBlockSize = expectedBlockSize;
00506 expectedRecordPtr->myReferenceID = 0;
00507 expectedRecordPtr->myPosition = 74;
00508 expectedRecordPtr->myReadNameLength = 21;
00509 expectedRecordPtr->myMapQuality = 0;
00510 expectedRecordPtr->myBin = 4681;
00511 expectedRecordPtr->myCigarLength = 1;
00512 expectedRecordPtr->myFlag = 97;
00513 expectedRecordPtr->myReadLength = 5;
00514 expectedRecordPtr->myMateReferenceID = 17;
00515 expectedRecordPtr->myMatePosition = 756;
00516 expectedRecordPtr->myInsertSize = 0;
00517
00518
00519 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
00520 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
00521 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
00522 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
00523 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
00524 assert(samRecord.getReadNameLength() ==
00525 expectedRecordPtr->myReadNameLength);
00526 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
00527 assert(samRecord.getBin() == expectedRecordPtr->myBin);
00528 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
00529 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
00530 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
00531 assert(samRecord.getMateReferenceID() ==
00532 expectedRecordPtr->myMateReferenceID);
00533 assert(strcmp(samRecord.getMateReferenceName(),
00534 expectedMateReferenceName) == 0);
00535 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
00536 expectedMateReferenceNameOrEqual) == 0);
00537 assert(samRecord.get1BasedMatePosition() ==
00538 expectedRecordPtr->myMatePosition + 1);
00539 assert(samRecord.get0BasedMatePosition() ==
00540 expectedRecordPtr->myMatePosition);
00541 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
00542 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:295") == 0);
00543 assert(strcmp(samRecord.getCigar(), "5M") == 0);
00544 assert(strcmp(samRecord.getSequence(), "ACGTN") == 0);
00545 assert(strcmp(samRecord.getQuality(), ";>>>>") == 0);
00546 assert(samRecord.getNumOverlaps(74, 79) == 5);
00547 assert(samRecord.getNumOverlaps(74, 78) == 4);
00548 assert(samRecord.getNumOverlaps(73, 79) == 5);
00549 assert(samRecord.getNumOverlaps(75, 79) == 4);
00550 assert(samRecord.getNumOverlaps(0, 179) == 5);
00551 assert(samRecord.getNumOverlaps(0, 19) == 0);
00552
00553
00554 assert(samRecord.get0BasedAlignmentEnd() == 78);
00555 assert(samRecord.get1BasedAlignmentEnd() == 79);
00556 assert(samRecord.getAlignmentLength() == 5);
00557 assert(samRecord.get0BasedUnclippedStart() == 74);
00558 assert(samRecord.get1BasedUnclippedStart() == 75);
00559 assert(samRecord.get0BasedUnclippedEnd() == 78);
00560 assert(samRecord.get1BasedUnclippedEnd() == 79);
00561
00562
00563
00564 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00565 assert(tag[0] == 'A');
00566 assert(tag[1] == 'M');
00567 assert(type == 'i');
00568 assert(*(char*)value == 0);
00569 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00570 assert(tag[0] == 'M');
00571 assert(tag[1] == 'D');
00572 assert(type == 'Z');
00573 assert(*(String*)value == "30A0C5");
00574 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00575 assert(tag[0] == 'N');
00576 assert(tag[1] == 'M');
00577 assert(type == 'i');
00578 assert(*(char*)value == 2);
00579 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00580 assert(tag[0] == 'X');
00581 assert(tag[1] == 'T');
00582 assert(type == 'A');
00583 assert(*(char*)value == 'R');
00584
00585 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00586 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00587
00588
00589 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
00590
00591 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
00592 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
00593 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
00594 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
00595 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
00596 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
00597 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
00598 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
00599 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
00600 assert(bufferPtr->myMateReferenceID ==
00601 expectedRecordPtr->myMateReferenceID);
00602 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
00603 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
00604
00605
00606
00607 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
00608
00609
00610 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
00611 {
00612 assert(*varPtr == samRecord.getReadName()[i]);
00613 varPtr++;
00614 }
00615
00616
00617
00618 assert(*(unsigned int*)varPtr == 80);
00619
00620 varPtr += 4;
00621
00622
00623
00624 assert(*varPtr == 0x12);
00625 varPtr++;
00626
00627 assert(*varPtr == 0x48);
00628 varPtr++;
00629
00630 assert(*varPtr == 0xF0);
00631 varPtr++;
00632
00633
00634 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
00635 {
00636 assert(*varPtr == samRecord.getQuality()[i] - 33);
00637 varPtr++;
00638 }
00639
00640
00641 assert(*varPtr == 'A');
00642 varPtr++;
00643 assert(*varPtr == 'M');
00644 varPtr++;
00645 assert(*varPtr == 'C');
00646 varPtr++;
00647 assert(*varPtr == 0);
00648 varPtr++;
00649 assert(*varPtr == 'M');
00650 varPtr++;
00651 assert(*varPtr == 'D');
00652 varPtr++;
00653 assert(*varPtr == 'Z');
00654 varPtr++;
00655 assert(*varPtr == '3');
00656 varPtr++;
00657 assert(*varPtr == '0');
00658 varPtr++;
00659 assert(*varPtr == 'A');
00660 varPtr++;
00661 assert(*varPtr == '0');
00662 varPtr++;
00663 assert(*varPtr == 'C');
00664 varPtr++;
00665 assert(*varPtr == '5');
00666 varPtr++;
00667 assert(*varPtr == 0);
00668 varPtr++;
00669 assert(*varPtr == 'N');
00670 varPtr++;
00671 assert(*varPtr == 'M');
00672 varPtr++;
00673 assert(*varPtr == 'C');
00674 varPtr++;
00675 assert(*varPtr == 2);
00676 varPtr++;
00677 assert(*varPtr == 'X');
00678 varPtr++;
00679 assert(*varPtr == 'T');
00680 varPtr++;
00681 assert(*varPtr == 'A');
00682 varPtr++;
00683 assert(*varPtr == 'R');
00684 varPtr++;
00685 }
00686
00687
00688 void validateRead4(SamRecord& samRecord)
00689 {
00690
00691
00692
00693 int expectedBlockSize = 57;
00694 const char* expectedReferenceName = "1";
00695 const char* expectedMateReferenceName = "18";
00696 const char* expectedMateReferenceNameOrEqual = "18";
00697
00698 bamRecordStruct* expectedRecordPtr =
00699 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
00700
00701 char tag[3];
00702 char type;
00703 void* value;
00704 bamRecordStruct* bufferPtr;
00705 unsigned char* varPtr;
00706
00707 expectedRecordPtr->myBlockSize = expectedBlockSize;
00708 expectedRecordPtr->myReferenceID = 0;
00709 expectedRecordPtr->myPosition = 74;
00710 expectedRecordPtr->myReadNameLength = 21;
00711 expectedRecordPtr->myMapQuality = 0;
00712 expectedRecordPtr->myBin = 4681;
00713 expectedRecordPtr->myCigarLength = 0;
00714 expectedRecordPtr->myFlag = 97;
00715 expectedRecordPtr->myReadLength = 0;
00716 expectedRecordPtr->myMateReferenceID = 17;
00717 expectedRecordPtr->myMatePosition = 756;
00718 expectedRecordPtr->myInsertSize = 0;
00719
00720
00721 assert(samRecord.get1BasedUnclippedEnd() == 75);
00722 assert(samRecord.get0BasedUnclippedEnd() == 74);
00723 assert(samRecord.get0BasedUnclippedStart() == 74);
00724 assert(samRecord.get1BasedUnclippedStart() == 75);
00725 assert(samRecord.get1BasedAlignmentEnd() == 75);
00726 assert(samRecord.get0BasedAlignmentEnd() == 74);
00727 assert(samRecord.getAlignmentLength() == 0);
00728
00729
00730 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
00731 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
00732 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
00733 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
00734 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
00735 assert(samRecord.getReadNameLength() ==
00736 expectedRecordPtr->myReadNameLength);
00737 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
00738 assert(samRecord.getBin() == expectedRecordPtr->myBin);
00739 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
00740 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
00741 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
00742 assert(samRecord.getMateReferenceID() ==
00743 expectedRecordPtr->myMateReferenceID);
00744 assert(strcmp(samRecord.getMateReferenceName(),
00745 expectedMateReferenceName) == 0);
00746 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
00747 expectedMateReferenceNameOrEqual) == 0);
00748 assert(samRecord.get1BasedMatePosition() ==
00749 expectedRecordPtr->myMatePosition + 1);
00750 assert(samRecord.get0BasedMatePosition() ==
00751 expectedRecordPtr->myMatePosition);
00752 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
00753 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:295") == 0);
00754 assert(strcmp(samRecord.getCigar(), "*") == 0);
00755 assert(strcmp(samRecord.getSequence(), "*") == 0);
00756 assert(strcmp(samRecord.getQuality(), "*") == 0);
00757
00758 bool caught = false;
00759 try
00760 {
00761 samRecord.getSequence(0);
00762 }
00763 catch (std::exception& e)
00764 {
00765 caught = true;
00766 assert(strcmp(e.what(), "SamRecord::getSequence(0) is not allowed since sequence = '*'") == 0);
00767 }
00768 assert(caught == true);
00769 caught = false;
00770 try
00771 {
00772 assert(samRecord.getQuality(0) == BaseUtilities::UNKNOWN_QUALITY_CHAR);
00773 }
00774 catch (std::exception& e)
00775 {
00776 caught = true;
00777 }
00778 assert(caught == false);
00779 try
00780 {
00781 samRecord.getSequence(-1);
00782 }
00783 catch (std::exception& e)
00784 {
00785 caught = true;
00786 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is not allowed since sequence = '*'") == 0);
00787 }
00788 assert(caught == true);
00789 caught = false;
00790 try
00791 {
00792 assert(samRecord.getQuality(-1) == BaseUtilities::UNKNOWN_QUALITY_CHAR);
00793 }
00794 catch (std::exception& e)
00795 {
00796 caught = true;
00797 }
00798 assert(caught == false);
00799
00800 caught = false;
00801 try
00802 {
00803 samRecord.getSequence(5);
00804 }
00805 catch (std::exception& e)
00806 {
00807 caught = true;
00808 assert(strcmp(e.what(), "SamRecord::getSequence(5) is not allowed since sequence = '*'") == 0);
00809 }
00810 assert(caught == true);
00811 caught = false;
00812 try
00813 {
00814 assert(samRecord.getQuality(5) == BaseUtilities::UNKNOWN_QUALITY_CHAR);
00815 }
00816 catch (std::exception& e)
00817 {
00818 caught = true;
00819 }
00820 assert(caught == false);
00821
00822 assert(samRecord.getNumOverlaps(74, 79) == 0);
00823 assert(samRecord.getNumOverlaps(74, 78) == 0);
00824 assert(samRecord.getNumOverlaps(73, 79) == 0);
00825 assert(samRecord.getNumOverlaps(75, 79) == 0);
00826 assert(samRecord.getNumOverlaps(0, 179) == 0);
00827 assert(samRecord.getNumOverlaps(0, 19) == 0);
00828
00829
00830 assert(samRecord.getNextSamTag(tag, type, &value) == true);
00831 assert(tag[0] == 'A');
00832 assert(tag[1] == 'M');
00833 assert(type == 'i');
00834 assert(*(char*)value == 0);
00835
00836 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00837 assert(samRecord.getNextSamTag(tag, type, &value) == false);
00838
00839
00840 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
00841
00842 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
00843 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
00844 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
00845 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
00846 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
00847 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
00848 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
00849 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
00850 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
00851 assert(bufferPtr->myMateReferenceID ==
00852 expectedRecordPtr->myMateReferenceID);
00853 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
00854 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
00855
00856
00857
00858 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
00859
00860
00861 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
00862 {
00863 assert(*varPtr == samRecord.getReadName()[i]);
00864 varPtr++;
00865 }
00866
00867
00868
00869
00870
00871
00872
00873 assert(*varPtr == 'A');
00874 varPtr++;
00875 assert(*varPtr == 'M');
00876 varPtr++;
00877 assert(*varPtr == 'C');
00878 varPtr++;
00879 assert(*varPtr == 0);
00880 varPtr++;
00881 }
00882
00883
00884 void validateRead5(SamRecord& samRecord)
00885 {
00886
00887
00888 int expectedBlockSize = 87;
00889 const char* expectedReferenceName = "2";
00890 const char* expectedMateReferenceName = "18";
00891 const char* expectedMateReferenceNameOrEqual = "18";
00892
00893 bamRecordStruct* expectedRecordPtr =
00894 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
00895
00896 char tag[3];
00897 char type;
00898 void* value;
00899 bamRecordStruct* bufferPtr;
00900 unsigned char* varPtr;
00901
00902 expectedRecordPtr->myBlockSize = expectedBlockSize;
00903 expectedRecordPtr->myReferenceID = 1;
00904 expectedRecordPtr->myPosition = 74;
00905 expectedRecordPtr->myReadNameLength = 21;
00906 expectedRecordPtr->myMapQuality = 0;
00907 expectedRecordPtr->myBin = 4681;
00908 expectedRecordPtr->myCigarLength = 1;
00909 expectedRecordPtr->myFlag = 97;
00910 expectedRecordPtr->myReadLength = 5;
00911 expectedRecordPtr->myMateReferenceID = 17;
00912 expectedRecordPtr->myMatePosition = 756;
00913 expectedRecordPtr->myInsertSize = 0;
00914
00915
00916 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
00917 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
00918 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
00919 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
00920 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
00921 assert(samRecord.getReadNameLength() ==
00922 expectedRecordPtr->myReadNameLength);
00923 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
00924 assert(samRecord.getBin() == expectedRecordPtr->myBin);
00925 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
00926 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
00927 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
00928 assert(samRecord.getMateReferenceID() ==
00929 expectedRecordPtr->myMateReferenceID);
00930 assert(strcmp(samRecord.getMateReferenceName(),
00931 expectedMateReferenceName) == 0);
00932 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
00933 expectedMateReferenceNameOrEqual) == 0);
00934 assert(samRecord.get1BasedMatePosition() ==
00935 expectedRecordPtr->myMatePosition + 1);
00936 assert(samRecord.get0BasedMatePosition() ==
00937 expectedRecordPtr->myMatePosition);
00938 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
00939 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:295") == 0);
00940 assert(strcmp(samRecord.getCigar(), "5M") == 0);
00941 assert(strcmp(samRecord.getSequence(), "ACGTN") == 0);
00942 assert(strcmp(samRecord.getQuality(), "*") == 0);
00943 assert(samRecord.getNumOverlaps(74, 79) == 5);
00944 assert(samRecord.getNumOverlaps(74, 78) == 4);
00945 assert(samRecord.getNumOverlaps(73, 79) == 5);
00946 assert(samRecord.getNumOverlaps(75, 79) == 4);
00947 assert(samRecord.getNumOverlaps(0, 179) == 5);
00948 assert(samRecord.getNumOverlaps(0, 19) == 0);
00949
00950 assert(samRecord.getSequence(0) == 'A');
00951 char expChar = 0xFF;
00952 assert(samRecord.getQuality(0) == expChar);
00953 assert(samRecord.getSequence(1) == 'C');
00954 assert(samRecord.getQuality(1) == expChar);
00955 assert(samRecord.getSequence(2) == 'G');
00956 assert(samRecord.getQuality(2) == expChar);
00957 assert(samRecord.getSequence(3) == 'T');
00958 assert(samRecord.getQuality(3) == expChar);
00959 assert(samRecord.getSequence(4) == 'N');
00960 assert(samRecord.getQuality(4) == expChar);
00961
00962 bool caught = false;
00963 try
00964 {
00965 samRecord.getSequence(-1);
00966 }
00967 catch (std::exception& e)
00968 {
00969 caught = true;
00970 assert(strcmp(e.what(), "SamRecord::getSequence(-1) is out of range. Index must be between 0 and 4") == 0);
00971 }
00972 assert(caught == true);
00973 caught = false;
00974 try
00975 {
00976 samRecord.getQuality(-1);
00977 }
00978 catch (std::exception& e)
00979 {
00980 caught = true;
00981 assert(strcmp(e.what(), "SamRecord::getQuality(-1) is out of range. Index must be between 0 and 4") == 0);
00982 }
00983 assert(caught == true);
00984
00985 caught = false;
00986 try
00987 {
00988 samRecord.getSequence(5);
00989 }
00990 catch (std::exception& e)
00991 {
00992 caught = true;
00993 assert(strcmp(e.what(), "SamRecord::getSequence(5) is out of range. Index must be between 0 and 4") == 0);
00994 }
00995 assert(caught == true);
00996 caught = false;
00997 try
00998 {
00999 samRecord.getQuality(5);
01000 }
01001 catch (std::exception& e)
01002 {
01003 caught = true;
01004 assert(strcmp(e.what(), "SamRecord::getQuality(5) is out of range. Index must be between 0 and 4") == 0);
01005 }
01006 assert(caught == true);
01007
01008
01009 assert(samRecord.getNextSamTag(tag, type, &value) == true);
01010 assert(tag[0] == 'A');
01011 assert(tag[1] == 'M');
01012 assert(type == 'i');
01013 assert(*(char*)value == 0);
01014 assert(samRecord.getNextSamTag(tag, type, &value) == true);
01015 assert(tag[0] == 'M');
01016 assert(tag[1] == 'D');
01017 assert(type == 'Z');
01018 assert(*(String*)value == "30A0C5");
01019 assert(samRecord.getNextSamTag(tag, type, &value) == true);
01020 assert(tag[0] == 'N');
01021 assert(tag[1] == 'M');
01022 assert(type == 'i');
01023 assert(*(char*)value == 2);
01024 assert(samRecord.getNextSamTag(tag, type, &value) == true);
01025 assert(tag[0] == 'X');
01026 assert(tag[1] == 'T');
01027 assert(type == 'A');
01028 assert(*(char*)value == 'R');
01029
01030 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01031 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01032
01033
01034 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
01035
01036 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
01037 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
01038 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
01039 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
01040 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
01041 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
01042 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
01043 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
01044 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
01045 assert(bufferPtr->myMateReferenceID ==
01046 expectedRecordPtr->myMateReferenceID);
01047 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
01048 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
01049
01050
01051
01052 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
01053
01054
01055 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
01056 {
01057 assert(*varPtr == samRecord.getReadName()[i]);
01058 varPtr++;
01059 }
01060
01061
01062
01063 assert(*(unsigned int*)varPtr == 80);
01064
01065 varPtr += 4;
01066
01067
01068
01069 assert(*varPtr == 0x12);
01070 varPtr++;
01071
01072 assert(*varPtr == 0x48);
01073 varPtr++;
01074
01075 assert(*varPtr == 0xF0);
01076 varPtr++;
01077
01078
01079 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
01080 {
01081 assert(*varPtr == 0xFF);
01082 varPtr++;
01083 }
01084
01085
01086 assert(*varPtr == 'A');
01087 varPtr++;
01088 assert(*varPtr == 'M');
01089 varPtr++;
01090 assert(*varPtr == 'C');
01091 varPtr++;
01092 assert(*varPtr == 0);
01093 varPtr++;
01094 assert(*varPtr == 'M');
01095 varPtr++;
01096 assert(*varPtr == 'D');
01097 varPtr++;
01098 assert(*varPtr == 'Z');
01099 varPtr++;
01100 assert(*varPtr == '3');
01101 varPtr++;
01102 assert(*varPtr == '0');
01103 varPtr++;
01104 assert(*varPtr == 'A');
01105 varPtr++;
01106 assert(*varPtr == '0');
01107 varPtr++;
01108 assert(*varPtr == 'C');
01109 varPtr++;
01110 assert(*varPtr == '5');
01111 varPtr++;
01112 assert(*varPtr == 0);
01113 varPtr++;
01114 assert(*varPtr == 'N');
01115 varPtr++;
01116 assert(*varPtr == 'M');
01117 varPtr++;
01118 assert(*varPtr == 'C');
01119 varPtr++;
01120 assert(*varPtr == 2);
01121 varPtr++;
01122 assert(*varPtr == 'X');
01123 varPtr++;
01124 assert(*varPtr == 'T');
01125 varPtr++;
01126 assert(*varPtr == 'A');
01127 varPtr++;
01128 assert(*varPtr == 'R');
01129 varPtr++;
01130 }
01131
01132
01133 void validateRead6(SamRecord& samRecord)
01134 {
01135
01136
01137
01138 int expectedBlockSize = 77;
01139 const char* expectedReferenceName = "1";
01140 const char* expectedMateReferenceName = "18";
01141 const char* expectedMateReferenceNameOrEqual = "18";
01142
01143 bamRecordStruct* expectedRecordPtr =
01144 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
01145
01146 char tag[3];
01147 char type;
01148 void* value;
01149 bamRecordStruct* bufferPtr;
01150 unsigned char* varPtr;
01151
01152 expectedRecordPtr->myBlockSize = expectedBlockSize;
01153 expectedRecordPtr->myReferenceID = 0;
01154 expectedRecordPtr->myPosition = 1750;
01155 expectedRecordPtr->myReadNameLength = 21;
01156 expectedRecordPtr->myMapQuality = 0;
01157 expectedRecordPtr->myBin = 4681;
01158 expectedRecordPtr->myCigarLength = 3;
01159 expectedRecordPtr->myFlag = 97;
01160 expectedRecordPtr->myReadLength = 8;
01161 expectedRecordPtr->myMateReferenceID = 17;
01162 expectedRecordPtr->myMatePosition = 756;
01163 expectedRecordPtr->myInsertSize = 0;
01164
01165
01166 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
01167 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
01168 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
01169 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
01170 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
01171 assert(samRecord.getReadNameLength() ==
01172 expectedRecordPtr->myReadNameLength);
01173 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
01174 assert(samRecord.getBin() == expectedRecordPtr->myBin);
01175 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
01176 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
01177 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
01178 assert(samRecord.getMateReferenceID() ==
01179 expectedRecordPtr->myMateReferenceID);
01180 assert(strcmp(samRecord.getMateReferenceName(),
01181 expectedMateReferenceName) == 0);
01182 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
01183 expectedMateReferenceNameOrEqual) == 0);
01184 assert(samRecord.get1BasedMatePosition() ==
01185 expectedRecordPtr->myMatePosition + 1);
01186 assert(samRecord.get0BasedMatePosition() ==
01187 expectedRecordPtr->myMatePosition);
01188 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
01189 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:296") == 0);
01190 assert(strcmp(samRecord.getCigar(), "3S2H5M") == 0);
01191 assert(strcmp(samRecord.getSequence(), "TGCACGTN") == 0);
01192 assert(strcmp(samRecord.getQuality(), "453;>>>>") == 0);
01193 assert(samRecord.getNumOverlaps(1750, 1755) == 5);
01194 assert(samRecord.getNumOverlaps(1750, 1754) == 4);
01195 assert(samRecord.getNumOverlaps(0, 2000) == 5);
01196 assert(samRecord.getNumOverlaps(1749, 1755) == 5);
01197 assert(samRecord.getNumOverlaps(1751, 1755) == 4);
01198 assert(samRecord.getNumOverlaps(0, 1752) == 2);
01199 assert(samRecord.getNumOverlaps(0, 19) == 0);
01200
01201
01202 assert(samRecord.get0BasedAlignmentEnd() == 1754);
01203 assert(samRecord.get1BasedAlignmentEnd() == 1755);
01204 assert(samRecord.getAlignmentLength() == 5);
01205 assert(samRecord.get0BasedUnclippedStart() == 1745);
01206 assert(samRecord.get1BasedUnclippedStart() == 1746);
01207 assert(samRecord.get0BasedUnclippedEnd() == 1754);
01208 assert(samRecord.get1BasedUnclippedEnd() == 1755);
01209
01210
01211 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01212
01213
01214 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
01215
01216 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
01217 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
01218 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
01219 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
01220 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
01221 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
01222 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
01223 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
01224 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
01225 assert(bufferPtr->myMateReferenceID ==
01226 expectedRecordPtr->myMateReferenceID);
01227 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
01228 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
01229
01230
01231
01232 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
01233
01234
01235 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
01236 {
01237 assert(*varPtr == samRecord.getReadName()[i]);
01238 varPtr++;
01239 }
01240
01241
01242
01243
01244 assert(*(unsigned int*)varPtr == 0x34);
01245
01246 varPtr += 4;
01247
01248 assert(*(unsigned int*)varPtr == 0x25);
01249
01250 varPtr += 4;
01251
01252 assert(*(unsigned int*)varPtr == 0x50);
01253
01254 varPtr += 4;
01255
01256
01257
01258 assert(*varPtr == 0x84);
01259 varPtr++;
01260
01261 assert(*varPtr == 0x21);
01262 varPtr++;
01263
01264 assert(*varPtr == 0x24);
01265 varPtr++;
01266
01267 assert(*varPtr == 0x8F);
01268 varPtr++;
01269
01270
01271 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
01272 {
01273 assert(*varPtr == samRecord.getQuality()[i] - 33);
01274 varPtr++;
01275 }
01276 }
01277
01278
01279 void validateRead7(SamRecord& samRecord)
01280 {
01281
01282
01283
01284 int expectedBlockSize = 83;
01285 const char* expectedReferenceName = "2";
01286 const char* expectedMateReferenceName = "18";
01287 const char* expectedMateReferenceNameOrEqual = "18";
01288
01289 bamRecordStruct* expectedRecordPtr =
01290 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
01291
01292 char tag[3];
01293 char type;
01294 void* value;
01295 bamRecordStruct* bufferPtr;
01296 unsigned char* varPtr;
01297
01298 expectedRecordPtr->myBlockSize = expectedBlockSize;
01299 expectedRecordPtr->myReferenceID = 1;
01300 expectedRecordPtr->myPosition = 1750;
01301 expectedRecordPtr->myReadNameLength = 21;
01302 expectedRecordPtr->myMapQuality = 0;
01303 expectedRecordPtr->myBin = 4681;
01304 expectedRecordPtr->myCigarLength = 4;
01305 expectedRecordPtr->myFlag = 97;
01306 expectedRecordPtr->myReadLength = 9;
01307 expectedRecordPtr->myMateReferenceID = 17;
01308 expectedRecordPtr->myMatePosition = 756;
01309 expectedRecordPtr->myInsertSize = 0;
01310
01311
01312 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
01313 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
01314 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
01315 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
01316 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
01317 assert(samRecord.getReadNameLength() ==
01318 expectedRecordPtr->myReadNameLength);
01319 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
01320 assert(samRecord.getBin() == expectedRecordPtr->myBin);
01321 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
01322 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
01323 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
01324 assert(samRecord.getMateReferenceID() ==
01325 expectedRecordPtr->myMateReferenceID);
01326 assert(strcmp(samRecord.getMateReferenceName(),
01327 expectedMateReferenceName) == 0);
01328 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
01329 expectedMateReferenceNameOrEqual) == 0);
01330 assert(samRecord.get1BasedMatePosition() ==
01331 expectedRecordPtr->myMatePosition + 1);
01332 assert(samRecord.get0BasedMatePosition() ==
01333 expectedRecordPtr->myMatePosition);
01334 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
01335 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:297") == 0);
01336 assert(strcmp(samRecord.getCigar(), "3S5M1S3H") == 0);
01337 assert(strcmp(samRecord.getSequence(), "TGCACGTNG") == 0);
01338 assert(strcmp(samRecord.getQuality(), "453;>>>>5") == 0);
01339 assert(samRecord.getNumOverlaps(1750, 1755) == 5);
01340 assert(samRecord.getNumOverlaps(1750, 1754) == 4);
01341 assert(samRecord.getNumOverlaps(0, 2000) == 5);
01342 assert(samRecord.getNumOverlaps(1749, 1755) == 5);
01343 assert(samRecord.getNumOverlaps(1751, 1755) == 4);
01344 assert(samRecord.getNumOverlaps(0, 1752) == 2);
01345 assert(samRecord.getNumOverlaps(0, 19) == 0);
01346
01347
01348 assert(samRecord.get0BasedAlignmentEnd() == 1754);
01349 assert(samRecord.get1BasedAlignmentEnd() == 1755);
01350 assert(samRecord.getAlignmentLength() == 5);
01351 assert(samRecord.get0BasedUnclippedStart() == 1747);
01352 assert(samRecord.get1BasedUnclippedStart() == 1748);
01353 assert(samRecord.get0BasedUnclippedEnd() == 1758);
01354 assert(samRecord.get1BasedUnclippedEnd() == 1759);
01355
01356
01357 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01358
01359
01360 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
01361
01362 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
01363 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
01364 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
01365 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
01366 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
01367 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
01368 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
01369 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
01370 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
01371 assert(bufferPtr->myMateReferenceID ==
01372 expectedRecordPtr->myMateReferenceID);
01373 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
01374 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
01375
01376
01377
01378 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
01379
01380
01381 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
01382 {
01383 assert(*varPtr == samRecord.getReadName()[i]);
01384 varPtr++;
01385 }
01386
01387
01388
01389
01390 assert(*(unsigned int*)varPtr == 0x34);
01391
01392 varPtr += 4;
01393
01394 assert(*(unsigned int*)varPtr == 0x50);
01395
01396 varPtr += 4;
01397
01398 assert(*(unsigned int*)varPtr == 0x14);
01399
01400 varPtr += 4;
01401
01402 assert(*(unsigned int*)varPtr == 0x35);
01403
01404 varPtr += 4;
01405
01406
01407
01408 assert(*varPtr == 0x84);
01409 varPtr++;
01410
01411 assert(*varPtr == 0x21);
01412 varPtr++;
01413
01414 assert(*varPtr == 0x24);
01415 varPtr++;
01416
01417 assert(*varPtr == 0x8F);
01418 varPtr++;
01419
01420 assert(*varPtr == 0x40);
01421 varPtr++;
01422
01423
01424 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
01425 {
01426 assert(*varPtr == samRecord.getQuality()[i] - 33);
01427 varPtr++;
01428 }
01429 }
01430
01431
01432 void validateRead8(SamRecord& samRecord)
01433 {
01434
01435
01436
01437 int expectedBlockSize = 65;
01438 const char* expectedReferenceName = "*";
01439 const char* expectedMateReferenceName = "*";
01440 const char* expectedMateReferenceNameOrEqual = "*";
01441
01442 bamRecordStruct* expectedRecordPtr =
01443 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
01444
01445 char tag[3];
01446 char type;
01447 void* value;
01448 bamRecordStruct* bufferPtr;
01449 unsigned char* varPtr;
01450
01451 expectedRecordPtr->myBlockSize = expectedBlockSize;
01452 expectedRecordPtr->myReferenceID = -1;
01453 expectedRecordPtr->myPosition = -1;
01454 expectedRecordPtr->myReadNameLength = 27;
01455 expectedRecordPtr->myMapQuality = 0;
01456 expectedRecordPtr->myBin = 4680;
01457 expectedRecordPtr->myCigarLength = 0;
01458 expectedRecordPtr->myFlag = 141;
01459 expectedRecordPtr->myReadLength = 4;
01460 expectedRecordPtr->myMateReferenceID = -1;
01461 expectedRecordPtr->myMatePosition = -1;
01462 expectedRecordPtr->myInsertSize = 0;
01463
01464
01465 assert(samRecord.get0BasedAlignmentEnd() == -1);
01466 assert(samRecord.get1BasedAlignmentEnd() == 0);
01467 assert(samRecord.getAlignmentLength() == 0);
01468 assert(samRecord.get0BasedUnclippedStart() == -1);
01469 assert(samRecord.get1BasedUnclippedStart() == 0);
01470 assert(samRecord.get0BasedUnclippedEnd() == -1);
01471 assert(samRecord.get1BasedUnclippedEnd() == 0);
01472
01473
01474 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
01475 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
01476 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
01477 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
01478 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
01479 assert(samRecord.getReadNameLength() ==
01480 expectedRecordPtr->myReadNameLength);
01481 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
01482 assert(samRecord.getBin() == expectedRecordPtr->myBin);
01483 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
01484 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
01485 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
01486 assert(samRecord.getMateReferenceID() ==
01487 expectedRecordPtr->myMateReferenceID);
01488 assert(strcmp(samRecord.getMateReferenceName(),
01489 expectedMateReferenceName) == 0);
01490 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
01491 expectedMateReferenceNameOrEqual) == 0);
01492 assert(samRecord.get1BasedMatePosition() ==
01493 expectedRecordPtr->myMatePosition + 1);
01494 assert(samRecord.get0BasedMatePosition() ==
01495 expectedRecordPtr->myMatePosition);
01496 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
01497 assert(strcmp(samRecord.getReadName(), "Y:16597235+13M13I11M:F:181") == 0);
01498 assert(strcmp(samRecord.getCigar(), "*") == 0);
01499 assert(strcmp(samRecord.getSequence(), "AACT") == 0);
01500 assert(strcmp(samRecord.getQuality(), "==;;") == 0);
01501 assert(samRecord.getNumOverlaps(1750, 1755) == 0);
01502 assert(samRecord.getNumOverlaps(1750, 1754) == 0);
01503 assert(samRecord.getNumOverlaps(0, 2000) == 0);
01504 assert(samRecord.getNumOverlaps(1749, 1755) == 0);
01505 assert(samRecord.getNumOverlaps(1751, 1755) == 0);
01506 assert(samRecord.getNumOverlaps(0, 1752) == 0);
01507 assert(samRecord.getNumOverlaps(0, 19) == 0);
01508 assert(samRecord.getNumOverlaps(-1, 4) == 0);
01509
01510
01511 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01512 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01513
01514
01515 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
01516
01517 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
01518 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
01519 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
01520 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
01521 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
01522 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
01523 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
01524 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
01525 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
01526 assert(bufferPtr->myMateReferenceID ==
01527 expectedRecordPtr->myMateReferenceID);
01528 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
01529 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
01530
01531
01532
01533 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
01534
01535
01536 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
01537 {
01538 assert(*varPtr == samRecord.getReadName()[i]);
01539 varPtr++;
01540 }
01541
01542
01543
01544
01545 assert(*varPtr == 0x11);
01546 varPtr++;
01547
01548 assert(*varPtr == 0x28);
01549 varPtr++;
01550
01551
01552 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
01553 {
01554 assert(*varPtr == samRecord.getQuality()[i] - 33);
01555 varPtr++;
01556 }
01557
01558
01559 }
01560
01561
01562 void validateRead9(SamRecord& samRecord)
01563 {
01564
01565
01566
01567 int expectedBlockSize = 77;
01568 const char* expectedReferenceName = "3";
01569 const char* expectedMateReferenceName = "18";
01570 const char* expectedMateReferenceNameOrEqual = "18";
01571
01572 bamRecordStruct* expectedRecordPtr =
01573 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
01574
01575 char tag[3];
01576 char type;
01577 void* value;
01578 bamRecordStruct* bufferPtr;
01579 unsigned char* varPtr;
01580
01581 expectedRecordPtr->myBlockSize = expectedBlockSize;
01582 expectedRecordPtr->myReferenceID = 2;
01583 expectedRecordPtr->myPosition = 74;
01584 expectedRecordPtr->myReadNameLength = 21;
01585 expectedRecordPtr->myMapQuality = 0;
01586 expectedRecordPtr->myBin = 4681;
01587 expectedRecordPtr->myCigarLength = 3;
01588 expectedRecordPtr->myFlag = 97;
01589 expectedRecordPtr->myReadLength = 8;
01590 expectedRecordPtr->myMateReferenceID = 17;
01591 expectedRecordPtr->myMatePosition = 756;
01592 expectedRecordPtr->myInsertSize = 0;
01593
01594
01595 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
01596 assert(samRecord.getStatus() == SamStatus::SUCCESS);
01597 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
01598 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
01599 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
01600 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
01601 assert(samRecord.getReadNameLength() ==
01602 expectedRecordPtr->myReadNameLength);
01603 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
01604 assert(samRecord.getBin() == expectedRecordPtr->myBin);
01605 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
01606 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
01607 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
01608 assert(samRecord.getMateReferenceID() ==
01609 expectedRecordPtr->myMateReferenceID);
01610 assert(strcmp(samRecord.getMateReferenceName(),
01611 expectedMateReferenceName) == 0);
01612 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
01613 expectedMateReferenceNameOrEqual) == 0);
01614 assert(samRecord.get1BasedMatePosition() ==
01615 expectedRecordPtr->myMatePosition + 1);
01616 assert(samRecord.get0BasedMatePosition() ==
01617 expectedRecordPtr->myMatePosition);
01618 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
01619 assert(strcmp(samRecord.getReadName(), "18:462+29M5I3M:F:298") == 0);
01620 assert(strcmp(samRecord.getCigar(), "3S5M4H") == 0);
01621 assert((strcmp(samRecord.getSequence(), "TGCACGTN") == 0) ||
01622 (strcmp(samRecord.getSequence(), "tgcacgtn") == 0));
01623 assert(strcmp(samRecord.getQuality(), "453;>>>>") == 0);
01624 assert(samRecord.getNumOverlaps(74, 79) == 5);
01625 assert(samRecord.getNumOverlaps(73, 79) == 5);
01626 assert(samRecord.getNumOverlaps(75, 78) == 3);
01627 assert(samRecord.getNumOverlaps(0, 1017) == 5);
01628 assert(samRecord.getNumOverlaps(79, 85) == 0);
01629 assert(samRecord.getNumOverlaps(78, 85) == 1);
01630 assert(samRecord.getNumOverlaps(-1, 1017) == 5);
01631
01632
01633 assert(samRecord.get0BasedAlignmentEnd() == 78);
01634 assert(samRecord.get1BasedAlignmentEnd() == 79);
01635 assert(samRecord.getAlignmentLength() == 5);
01636 assert(samRecord.get0BasedUnclippedStart() == 71);
01637 assert(samRecord.get1BasedUnclippedStart() == 72);
01638 assert(samRecord.get0BasedUnclippedEnd() == 82);
01639 assert(samRecord.get1BasedUnclippedEnd() == 83);
01640
01641
01642 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01643
01644
01645 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
01646 assert(bufferPtr != NULL);
01647
01648 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
01649 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
01650 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
01651 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
01652 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
01653 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
01654 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
01655 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
01656 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
01657 assert(bufferPtr->myMateReferenceID ==
01658 expectedRecordPtr->myMateReferenceID);
01659 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
01660 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
01661
01662
01663
01664 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
01665
01666
01667 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
01668 {
01669 assert(*varPtr == samRecord.getReadName()[i]);
01670 varPtr++;
01671 }
01672
01673
01674
01675
01676 assert(*(unsigned int*)varPtr == 0x34);
01677
01678 varPtr += 4;
01679
01680 assert(*(unsigned int*)varPtr == 0x50);
01681
01682 varPtr += 4;
01683
01684 assert(*(unsigned int*)varPtr == 0x45);
01685
01686 varPtr += 4;
01687
01688
01689
01690 assert(*varPtr == 0x84);
01691 varPtr++;
01692
01693 assert(*varPtr == 0x21);
01694 varPtr++;
01695
01696 assert(*varPtr == 0x24);
01697 varPtr++;
01698
01699 assert(*varPtr == 0x8F);
01700 varPtr++;
01701
01702
01703 for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
01704 {
01705 assert(*varPtr == samRecord.getQuality()[i] - 33);
01706 varPtr++;
01707 }
01708 }
01709
01710
01711 void validateRead10(SamRecord& samRecord)
01712 {
01713
01714
01715
01716 int expectedBlockSize = 59;
01717 const char* expectedReferenceName = "*";
01718 const char* expectedMateReferenceName = "*";
01719 const char* expectedMateReferenceNameOrEqual = "*";
01720
01721 bamRecordStruct* expectedRecordPtr =
01722 (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
01723
01724 char tag[3];
01725 char type;
01726 void* value;
01727 bamRecordStruct* bufferPtr;
01728 unsigned char* varPtr;
01729
01730 expectedRecordPtr->myBlockSize = expectedBlockSize;
01731 expectedRecordPtr->myReferenceID = -1;
01732 expectedRecordPtr->myPosition = -1;
01733 expectedRecordPtr->myReadNameLength = 27;
01734 expectedRecordPtr->myMapQuality = 0;
01735 expectedRecordPtr->myBin = 4680;
01736 expectedRecordPtr->myCigarLength = 0;
01737 expectedRecordPtr->myFlag = 141;
01738 expectedRecordPtr->myReadLength = 0;
01739 expectedRecordPtr->myMateReferenceID = -1;
01740 expectedRecordPtr->myMatePosition = -1;
01741 expectedRecordPtr->myInsertSize = 0;
01742
01743
01744 assert(samRecord.get0BasedUnclippedStart() == -1);
01745 assert(samRecord.get1BasedUnclippedStart() == 0);
01746 assert(samRecord.get0BasedUnclippedEnd() == -1);
01747 assert(samRecord.get1BasedUnclippedEnd() == 0);
01748 assert(samRecord.get1BasedAlignmentEnd() == 0);
01749 assert(samRecord.get0BasedAlignmentEnd() == -1);
01750 assert(samRecord.getAlignmentLength() == 0);
01751
01752
01753 assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
01754 assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
01755 assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
01756 assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
01757 assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
01758 assert(samRecord.getReadNameLength() ==
01759 expectedRecordPtr->myReadNameLength);
01760 assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
01761 assert(samRecord.getBin() == expectedRecordPtr->myBin);
01762 assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
01763 assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
01764 assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
01765 assert(samRecord.getMateReferenceID() ==
01766 expectedRecordPtr->myMateReferenceID);
01767 assert(strcmp(samRecord.getMateReferenceName(),
01768 expectedMateReferenceName) == 0);
01769 assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
01770 expectedMateReferenceNameOrEqual) == 0);
01771 assert(samRecord.get1BasedMatePosition() ==
01772 expectedRecordPtr->myMatePosition + 1);
01773 assert(samRecord.get0BasedMatePosition() ==
01774 expectedRecordPtr->myMatePosition);
01775 assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
01776 assert(strcmp(samRecord.getReadName(), "Y:16597235+13M13I11M:F:181") == 0);
01777 assert(strcmp(samRecord.getCigar(), "*") == 0);
01778 assert(strcmp(samRecord.getSequence(), "*") == 0);
01779 assert(strcmp(samRecord.getQuality(), "*") == 0);
01780 assert(samRecord.getNumOverlaps(74, 79) == 0);
01781 assert(samRecord.getNumOverlaps(73, 79) == 0);
01782 assert(samRecord.getNumOverlaps(75, 78) == 0);
01783 assert(samRecord.getNumOverlaps(0, 1017) == 0);
01784 assert(samRecord.getNumOverlaps(79, 85) == 0);
01785 assert(samRecord.getNumOverlaps(78, 85) == 0);
01786 assert(samRecord.getNumOverlaps(-1, 1017) == 0);
01787
01788
01789 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01790 assert(samRecord.getNextSamTag(tag, type, &value) == false);
01791
01792
01793 bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
01794
01795 assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
01796 assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
01797 assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
01798 assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
01799 assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
01800 assert(bufferPtr->myBin == expectedRecordPtr->myBin);
01801 assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
01802 assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
01803 assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
01804 assert(bufferPtr->myMateReferenceID ==
01805 expectedRecordPtr->myMateReferenceID);
01806 assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
01807 assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
01808
01809
01810
01811 varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
01812
01813
01814 for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
01815 {
01816 assert(*varPtr == samRecord.getReadName()[i]);
01817 varPtr++;
01818 }
01819
01820
01821
01822
01823
01824 }
01825
01826
01827 void validateHeader(SamFileHeader& samHeader)
01828 {
01829 validateHeaderFields(samHeader);
01830 validateHeaderString(samHeader);
01831 }
01832
01833
01834 void validateHeaderFields(SamFileHeader& samHeader)
01835 {
01836 const char* value;
01837
01838
01839
01840
01841 value = samHeader.getHDTagValue("GO");
01842 assert(strcmp(value, "") == 0);
01843
01844
01845
01846
01847 value = samHeader.getPGTagValue("CL", "1");
01848 assert(strcmp(value, "") == 0);
01849
01850
01851
01852 value = samHeader.getSQTagValue("LN", "1");
01853 assert(value != NULL);
01854 assert(strcmp(value, "247249719") == 0);
01855 value = samHeader.getSQTagValue("LN", "22");
01856 assert(value != NULL);
01857 assert(strcmp(value, "49691432") == 0);
01858
01859
01860
01861
01862 value = samHeader.getSQTagValue("LN", "1000");
01863 assert(strcmp(value, "") == 0);
01864
01865
01866
01867
01868 value = samHeader.getSQTagValue("AS", "1");
01869 assert(strcmp(value, "") == 0);
01870
01871
01872
01873 value = samHeader.getRGTagValue("LB", "myID2");
01874 assert(value != NULL);
01875 assert(strcmp(value, "library2") == 0);
01876 value = samHeader.getRGTagValue("LB", "myID");
01877 assert(value != NULL);
01878 assert(strcmp(value, "library") == 0);
01879
01880
01881
01882
01883 SamHeaderSQ* sq = samHeader.getSQ("10");
01884 assert(strcmp(sq->getTagValue("SN"), "10") == 0);
01885 assert(strcmp(sq->getTagValue("LN"), "135374737") == 0);
01886
01887
01888 assert(strcmp(sq->getTagValue("DD"), "") == 0);
01889
01890
01891
01892
01893
01894 const SamHeaderRG* rg = samHeader.getRG("myID");
01895 assert(strcmp(rg->getTagValue("ID"), "myID") == 0);
01896 assert(strcmp(rg->getTagValue("SM"), "sample") == 0);
01897 assert(strcmp(rg->getTagValue("LB"), "library") == 0);
01898
01899
01900 assert(strcmp(rg->getTagValue("DD"), "") == 0);
01901
01902
01903
01904 rg = samHeader.getRG("noExist");
01905 assert(rg == NULL);
01906
01907
01908
01909 sq = samHeader.getSQ("noExist");
01910 assert(sq == NULL);
01911
01912
01913
01914 assert(samHeader.getReferenceID("2") == 1);
01915 std::string refIDStdString = "X";
01916 assert(samHeader.getReferenceID(refIDStdString.c_str()) == 22);
01917 String refIDString = "22";
01918 assert(samHeader.getReferenceID(refIDString) == 21);
01919 assert(samHeader.getReferenceID(refIDString.c_str()) == 21);
01920 assert(samHeader.getReferenceID("Z") == 23);
01921 assert(samHeader.getReferenceID("*") == -1);
01922 refIDString = "*";
01923 assert(samHeader.getReferenceID(refIDString) == -1);
01924 assert(samHeader.getReferenceID(refIDString.c_str()) == -1);
01925 }
01926
01927 void validateHeaderString(SamFileHeader& samHeader)
01928 {
01929
01930 std::string headerString = "";
01931 assert(samHeader.getHeaderString(headerString) == true);
01932 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");
01933 }