public void TestParser()
{
const string FilePath = @"TestUtils\BAM\SeqAlignment.bam";
BAMParser parser = null;
try
{
parser = new BAMParser();
SequenceAlignmentMap alignmentMap = parser.ParseOne<SequenceAlignmentMap>(FilePath);
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
}
finally
{
if (parser != null)
parser.Dispose();
}
}
public void TestFormatter()
{
string filePath = @"TestUtils\BAM\SeqAlignment.bam";
string outputfilePath = "BAMTests123.bam";
BAMParser parser = null;
try
{
parser = new BAMParser();
BAMFormatter formatter = new BAMFormatter();
SequenceAlignmentMap alignmentMap = parser.Parse(filePath);
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
formatter.Format(alignmentMap, outputfilePath);
formatter.CreateSortedBAMFile = true;
formatter.CreateIndexFile = true;
alignmentMap = parser.Parse(filePath);
formatter.Format(alignmentMap, outputfilePath);
Assert.IsTrue(File.Exists("BAMTests123.bam.bai"));
alignmentMap = parser.Parse(outputfilePath);
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
alignmentMap = parser.ParseRange("BAMTests123.bam", new SequenceRange("chr20", 0, int.MaxValue));
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
alignmentMap = parser.ParseRange("BAMTests123.bam", new SequenceRange("chr20", 0, 28833));
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 1);
}
finally
{
if (parser != null)
parser.Dispose();
}
}
public void TestFormatterWithSort()
{
string inputFilePath = @"TestUtils\BAM\SeqAlignment.bam";
string outputFilePath1 = "output1.bam";
string outputFilePath2 = "output2.bam";
BAMParser parser = null;
try
{
parser = new BAMParser();
BAMFormatter formatter = new BAMFormatter();
SequenceAlignmentMap alignmentMap = parser.Parse(inputFilePath);
Assert.IsTrue(alignmentMap != null);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
formatter.CreateSortedBAMFile = true;
formatter.SortType = BAMSortByFields.ChromosomeCoordinates;
formatter.Format(alignmentMap, outputFilePath1);
alignmentMap = parser.Parse(inputFilePath);
formatter.Format(alignmentMap, outputFilePath2);
Assert.IsTrue(File.Exists(outputFilePath1));
Assert.IsTrue(File.Exists(outputFilePath2));
Assert.AreEqual(true, FileCompare(outputFilePath1, outputFilePath2));
}
finally
{
if (parser != null)
parser.Dispose();
}
}
/// <summary>
/// Parse BAM and validate parsed aligned sequences and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
/// <param name="IsEncoding">
/// True for BAMParser ctor with encoding.
/// False otherwise
/// </param>
private void ValidateBAMParser(string nodeName,
BAMParserParameters BAMParserPam,
bool IsReferenceIndex)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string refIndexValue = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.RefIndexNode);
string startIndexValue = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.StartIndexNode);
string endIndexValue = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.EndIndexNode);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
string refSeqName = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ChromosomeNameNode);
SequenceAlignmentMap seqAlignment = null;
BAMParser bamParser = null;
try
{
bamParser = new BAMParser();
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.StreamReader:
using (Stream stream = new FileStream(bamFilePath, FileMode.Open,
FileAccess.Read))
{
seqAlignment = bamParser.ParseOne(stream);
}
break;
case BAMParserParameters.FileName:
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
break;
case BAMParserParameters.ParseRangeFileName:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, null));
break;
case BAMParserParameters.ParseRangeWithIndex:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, null),
Convert.ToInt32(startIndexValue, null),
Convert.ToInt32(endIndexValue, null));
break;
case BAMParserParameters.ParseRangeUsingRefSeq:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName);
break;
case BAMParserParameters.ParseRangeUsingRefSeqAndFlag:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName);
break;
case BAMParserParameters.ParseRangeUsingRefSeqUsingIndex:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName,
Convert.ToInt32(startIndexValue, null),
Convert.ToInt32(endIndexValue, null));
break;
case BAMParserParameters.ParseRangeUsingIndexesAndFlag:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName,
Convert.ToInt32(startIndexValue, null),
Convert.ToInt32(endIndexValue, null));
break;
}
// Validate BAM Header record fileds.
if (!IsReferenceIndex)
{
this.ValidateBAMHeaderRecords(nodeName, seqAlignment);
}
IList<SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider) null));
// Get expected sequences
var parserObj = new FastAParser();
{
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
IList<ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.IsFalse(alignedSeqs[index].IsDummyRead);
Assert.AreEqual(
new string(expectedSequencesList[index].Select(a => (char) a).ToArray()),
new string(alignedSeqs[index].QuerySequence.Select(a => (char) a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence));
}
}
}
finally
{
bamParser.Dispose();
}
}
public void ValidateErrorIndexingUnsortedBAM()
{
//samtools throws the following error, we should do the same
//[bam_index_core] the alignment is not sorted (H0KTMADXX130517:2:1111:17648:28366): 12370 > 12324 in 25-th chr
// Get filepath from xml config file.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMUnsortedFilePath, Constants.FilePathNode);
using (Stream bamStream = new FileStream(bamFilePath, FileMode.Open, FileAccess.Read))
{
BAMParser parser = new BAMParser();
BAMIndex bamIndex;
try
{
bamIndex = parser.GetIndexFromBAMStorage(bamStream);
Assert.Fail();
}
catch(InvalidDataException)
{
}
catch(Exception) {
Assert.Fail();
}
finally
{
parser.Dispose();
}
}
// Log message to VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated error is thrown on indexing unsorted file"));
}
public void ValidateGetInsertLengthWithValidate()
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(Constants.PairedReadTypesForLibraryInfoNode,
Constants.FilePathNode);
string mean = this.utilityObj.xmlUtil.GetTextValue(
Constants.PairedReadTypesForLibraryInfoNode, Constants.MeanNode);
string deviation = this.utilityObj.xmlUtil.GetTextValue(
Constants.PairedReadTypesForLibraryInfoNode, Constants.DeviationValueNode);
string[] insertLength = this.utilityObj.xmlUtil.GetTextValue(
Constants.PairedReadTypesForLibraryInfoNode, Constants.InsertLengthNode).Split(',');
using (var bamParser = new BAMParser())
{
SequenceAlignmentMap seqAlignmentMapObj = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
int i = 0;
try
{
IList<PairedRead> pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
//pass true for validate parameter
int length = PairedRead.GetInsertLength(read.Read1, read.Read2, true);
Assert.AreEqual(length.ToString((IFormatProvider) null), insertLength[i]);
i++;
}
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated GetInsertLength Successfully"));
}
finally
{
bamParser.Dispose();
}
}
}
/// <summary>
/// Validate different paired read types
/// </summary>
/// <param name="nodeName">XML node name</param>
/// <param name="pams">GetPairedReadTypes method parameters</param>
private void ValidatePairedReadTypes(string nodeName, GetPairedReadTypeParameters pams)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string mean = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.MeanNode);
string deviation = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DeviationValueNode);
string library = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.LibraryNameNode);
string[] pairedReadType = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadTypeNode).Split(',');
string[] insertLength = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InsertLengthNode).Split(',');
var bamParser = new BAMParser();
SequenceAlignmentMap seqAlignmentMapObj = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
CloneLibraryInformation libraryInfo;
int i = 0;
try
{
IList<PairedRead> pairedReads;
switch (pams)
{
case GetPairedReadTypeParameters.PaireReadTypeUsingLibraryName:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read, library);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingCloneLibraryInfo:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
libraryInfo = CloneLibrary.Instance.GetLibraryInformation(library);
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read, libraryInfo);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingMeanAndDeviation:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read, float.Parse(mean, null),
float.Parse(deviation, null));
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingReadsAndLibrary:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read.Read1,
read.Read2, library);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.PaireReadTypeUsingReadsAndLibraryInfo:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
libraryInfo = CloneLibrary.Instance.GetLibraryInformation(library);
foreach (PairedRead read in pairedReads)
{
PairedReadType type = PairedRead.GetPairedReadType(read.Read1,
read.Read2, libraryInfo);
Assert.AreEqual(type.ToString(), pairedReadType[i]);
i++;
}
break;
case GetPairedReadTypeParameters.GetInsertLength:
pairedReads = seqAlignmentMapObj.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
libraryInfo = CloneLibrary.Instance.GetLibraryInformation(library);
foreach (PairedRead read in pairedReads)
{
int length = PairedRead.GetInsertLength(read.Read1, read.Read2);
Assert.AreEqual(length.ToString((IFormatProvider) null), insertLength[i]);
i++;
}
break;
}
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated Paired read Type Successfully"));
}
finally
{
bamParser.Dispose();
}
}
/// <summary>
/// Validate GetPaired method
/// </summary>
/// <param name="nodeName">XML node name</param>
/// <param name="pams">GetPairedReads method parameters</param>
private void ValidatePairedReads(string nodeName, GetPairedReadParameters pams)
{
// Get input and output values from xml node.
string bamFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string mean = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.MeanNode);
string deviation = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DeviationValueNode);
string library = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.LibraryNameNode);
string pairedReadsCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadsNode);
string[] insertLength = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InsertLengthNode).Split(',');
string[] pairedReadType = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.PairedReadTypeNode).Split(',');
SequenceAlignmentMap seqAlignment = null;
IList<PairedRead> pairedReads = null;
var bamParser = new BAMParser();
var parserObj = new FastAParser();
try
{
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(bamFilePath);
IEnumerable<ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
switch (pams)
{
case GetPairedReadParameters.GetPairedReadWithParameters:
pairedReads = seqAlignment.GetPairedReads(float.Parse(mean, null),
float.Parse(deviation, null));
break;
case GetPairedReadParameters.GetPairedReadWithLibraryName:
pairedReads = seqAlignment.GetPairedReads(library);
break;
case GetPairedReadParameters.GetPairedReadWithCloneLibraryInfo:
CloneLibraryInformation libraryInfo =
CloneLibrary.Instance.GetLibraryInformation(library);
pairedReads = seqAlignment.GetPairedReads(libraryInfo);
break;
case GetPairedReadParameters.Default:
pairedReads = seqAlignment.GetPairedReads();
break;
}
Assert.AreEqual(pairedReadsCount, pairedReads.Count.ToString((IFormatProvider) null));
int i = 0;
foreach (PairedRead read in pairedReads)
{
Assert.AreEqual(insertLength[i], read.InsertLength.ToString((IFormatProvider) null));
Assert.AreEqual(pairedReadType[i], read.PairedType.ToString());
foreach (SAMAlignedSequence seq in read.Reads)
{
Assert.AreEqual(new string(expectedSequences.ElementAt(i).Select(a => (char) a).ToArray()),
new string(seq.QuerySequence.Select(a => (char) a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser BVT : Validated Paired read :{0} successfully",
seq.QuerySequence));
}
i++;
}
}
finally
{
bamParser.Dispose();
}
}
