/// <summary>
/// Validate formatted BAM file.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Format method parameters</param>
void ValidateBAMFormatter(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string alignedSeqCount = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
Stream stream = null;
SequenceAlignmentMap seqAlignment = null;
using (BAMParser bamParserObj = new BAMParser())
{
// Parse a BAM file.
seqAlignment = bamParserObj.Parse(bamFilePath);
// Create a BAM formatter object.
BAMFormatter formatterObj = new BAMFormatter();
// Write/Format aligned sequences to BAM file.
switch (BAMParserPam)
{
case BAMParserParameters.StreamWriter:
using (stream = new
FileStream(Constants.BAMTempFileName,
FileMode.Create, FileAccess.Write))
{
formatterObj.Format(seqAlignment, stream);
}
break;
case BAMParserParameters.FileName:
formatterObj.Format(seqAlignment, Constants.BAMTempFileName);
break;
case BAMParserParameters.IndexFile:
formatterObj.Format(seqAlignment, Constants.BAMTempFileName,
Constants.BAMTempIndexFile);
File.Exists(Constants.BAMTempIndexFile);
break;
default:
break;
}
// Parse formatted BAM file and validate aligned sequences.
SequenceAlignmentMap expectedSeqAlignmentMap = bamParserObj.Parse(
Constants.BAMTempFileName);
// Validate Parsed BAM file Header record fileds.
ValidateBAMHeaderRecords(nodeName, expectedSeqAlignmentMap);
IList <SAMAlignedSequence> alignedSeqs = expectedSeqAlignmentMap.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected sequences
using (FastaParser parserObj = new FastaParser())
{
IList <ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(expectedSequences[index].ToString(),
alignedSeqs[index].QuerySequence.ToString());
// Log to NUNIT GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Formatter BVT : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
Console.WriteLine(string.Format((IFormatProvider)null,
"BAM Formatter BVT : Validated the aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
}
File.Delete(Constants.BAMTempFileName);
File.Delete(Constants.BAMTempIndexFile);
}
/// <summary>
/// Validate formatted BAM file.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Format method parameters</param>
private void ValidateBAMFormatter(string nodeName,
BAMParserParameters BAMParserPam)
{
// 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 alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
using (var bamParserObj = new BAMParser())
{
// Parse a BAM file.
var seqAlignment = bamParserObj.ParseOne<SequenceAlignmentMap>(bamFilePath);
// Create a BAM formatter object.
var formatterObj = new BAMFormatter();
// Write/Format aligned sequences to BAM file.
switch (BAMParserPam)
{
case BAMParserParameters.StreamWriter:
Stream stream;
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.Create, FileAccess.Write))
{
formatterObj.Format(stream, seqAlignment);
}
break;
case BAMParserParameters.FileName:
formatterObj.Format(seqAlignment, Constants.BAMTempFileName);
break;
case BAMParserParameters.IndexFile:
formatterObj.Format(seqAlignment, Constants.BAMTempFileName, Constants.BAMTempIndexFile);
File.Exists(Constants.BAMTempIndexFile);
break;
default:
break;
}
// Parse formatted BAM file and validate aligned sequences.
SequenceAlignmentMap expectedSeqAlignmentMap = bamParserObj.ParseOne<SequenceAlignmentMap>(Constants.BAMTempFileName);
// Validate Parsed BAM file Header record fileds.
this.ValidateBAMHeaderRecords(nodeName, expectedSeqAlignmentMap);
IList<SAMAlignedSequence> alignedSeqs = expectedSeqAlignmentMap.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.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("BAM Formatter BVT : Validated Aligned sequence :{0} successfully", alignedSeqs[index].QuerySequence));
}
}
}
File.Delete(Constants.BAMTempFileName);
File.Delete(Constants.BAMTempIndexFile);
}
/// <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>
void ValidateBAMParser(string nodeName,
BAMParserParameters BAMParserPam, bool IsEncoding,
bool IsReferenceIndex)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string refIndexValue = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.RefIndexNode);
string startIndexValue = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.StartIndexNode);
string endIndexValue = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.EndIndexNode);
string alignedSeqCount = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
SequenceAlignmentMap seqAlignment = null;
BAMParser bamParser = null;
try
{
if (IsEncoding)
{
bamParser = new BAMParser();
}
else
{
bamParser = new BAMParser(Encodings.IupacNA);
}
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.StreamReader:
using (Stream stream = new FileStream(bamFilePath, FileMode.Open,
FileAccess.Read))
{
seqAlignment = bamParser.Parse(stream);
}
break;
case BAMParserParameters.StreamReaderWithReadOnly:
using (Stream stream = new FileStream(bamFilePath, FileMode.Open,
FileAccess.Read))
{
seqAlignment = bamParser.Parse(stream, false);
}
break;
case BAMParserParameters.FileName:
seqAlignment = bamParser.Parse(bamFilePath);
break;
case BAMParserParameters.FileNameWithReadOnly:
seqAlignment = bamParser.Parse(bamFilePath, false);
break;
case BAMParserParameters.ParseRangeFileName:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, (IFormatProvider)null));
break;
case BAMParserParameters.ParseRangeFileNameWithReadOnly:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, (IFormatProvider)null), false);
break;
case BAMParserParameters.ParseRangeWithIndex:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, (IFormatProvider)null),
Convert.ToInt32(startIndexValue, (IFormatProvider)null),
Convert.ToInt32(endIndexValue, (IFormatProvider)null), false);
break;
}
// Validate BAM Header record fileds.
if (!IsReferenceIndex)
{
ValidateBAMHeaderRecords(nodeName, seqAlignment);
}
IList <SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected sequences
using (FastaParser parserObj = new FastaParser())
{
IList <ISequence> expectedSequences = parserObj.Parse(expectedAlignedSeqFilePath);
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(expectedSequences[index].ToString(),
alignedSeqs[index].QuerySequence.ToString());
// Log to NUNIT GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
Console.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated the aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
}
finally
{
bamParser.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>
void ValidateBAMParser(string nodeName,
BAMParserParameters BAMParserPam,
bool IsReferenceIndex)
{
// Get input and output values from xml node.
string bamFilePath = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string refIndexValue = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.RefIndexNode);
string startIndexValue = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.StartIndexNode);
string endIndexValue = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.EndIndexNode);
string alignedSeqCount = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
string refSeqName = 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.Parse(stream);
}
break;
case BAMParserParameters.FileName:
seqAlignment = bamParser.Parse(bamFilePath);
break;
case BAMParserParameters.ParseRangeFileName:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, (IFormatProvider)null));
break;
case BAMParserParameters.ParseRangeWithIndex:
seqAlignment = bamParser.ParseRange(bamFilePath,
Convert.ToInt32(refIndexValue, (IFormatProvider)null),
Convert.ToInt32(startIndexValue, (IFormatProvider)null),
Convert.ToInt32(endIndexValue, (IFormatProvider)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, (IFormatProvider)null),
Convert.ToInt32(endIndexValue, (IFormatProvider)null));
break;
case BAMParserParameters.ParseRangeUsingIndexesAndFlag:
seqAlignment = bamParser.ParseRange(bamFilePath, refSeqName,
Convert.ToInt32(startIndexValue, (IFormatProvider)null),
Convert.ToInt32(endIndexValue, (IFormatProvider)null));
break;
}
// Validate BAM Header record fileds.
if (!IsReferenceIndex)
{
ValidateBAMHeaderRecords(nodeName, seqAlignment);
}
IList <SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected sequences
using (FastAParser parserObj = new FastAParser(expectedAlignedSeqFilePath))
{
IEnumerable <ISequence> expectedSequences = parserObj.Parse();
IList <ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate aligned sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
Assert.AreEqual(
new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignedSeqs[index].QuerySequence.Select(a => (char)a).ToArray()));
// Log to NUNIT GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
Console.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated the aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
}
finally
{
bamParser.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();
}
}
/// <summary>
/// Parse BAM and validate parsed aligned sequences by creating
/// ISequenceAlignment interface object and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
private void InValidateSeqAlignmentMapBAMParser(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode);
string exception = string.Empty;
using (var bamParser = new BAMParser())
{
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.StreamReader:
try
{
bamParser.Parse(null as Stream);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
exception = ex.Message;
}
try
{
using (Stream stream = new FileStream(bamFilePath, FileMode.Open, FileAccess.Read))
{
bamParser.Parse(stream).ToList();
Assert.Fail();
}
}
catch (Exception ex)
{
exception = ex.Message;
}
break;
case BAMParserParameters.FileName:
try
{
bamParser.Parse(null as string).First();
Assert.Fail();
}
catch (ArgumentNullException ex)
{
exception = ex.Message;
}
break;
case BAMParserParameters.ParseRangeWithIndex:
try
{
bamParser.ParseRange(null, 0);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
exception = ex.Message;
}
try
{
bamParser.ParseRange(bamFilePath, -2);
Assert.Fail();
}
catch (ArgumentOutOfRangeException ex)
{
exception = ex.Message;
}
break;
case BAMParserParameters.ParseRangeFileName:
try
{
bamParser.ParseRange(null, new SequenceRange("chr20", 0, 10));
Assert.Fail();
}
catch (ArgumentNullException ex)
{
exception = ex.Message;
}
try
{
bamParser.ParseRange(bamFilePath, null as SequenceRange);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
exception = ex.Message;
}
break;
default:
break;
}
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", exception));
}
}
/// <summary>
/// Parse BAM File and Invalidate parsed aligned sequences by creating
/// ISequenceAlignment interface object and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
private void InValidateISequenceAlignmentBAMParser(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string exception = string.Empty;
ISequenceAlignmentParser bamParser = null;
bamParser = new BAMParser();
try
{
// Parse a BAM file with different invalid parameters.
switch (BAMParserPam)
{
case BAMParserParameters.Stream:
try
{
using (var reader = File.OpenRead(bamFilePath))
{
bamParser.Parse(reader);
Assert.Fail();
}
}
catch (NotSupportedException ex)
{
exception = ex.Message;
}
break;
case BAMParserParameters.ParseOneStream:
try
{
using (var reader = File.OpenRead(bamFilePath))
{
bamParser.ParseOne(reader);
Assert.Fail();
}
}
catch (NotSupportedException ex)
{
exception = ex.Message;
}
break;
default:
break;
}
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format(null,
"BAM Parser P2 : Validated Exception {0} successfully",
exception));
}
finally
{
(bamParser as BAMParser).Dispose();
}
}
/// <summary>
/// Format BAM file using IsequenceAlignment object.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Format method parameters</param>
/// <param name="WriteBAMIndexData">True if writting BAM index data to BAMIndex file,
/// false otherwise</param>
/// <param name="IsNotSupportedMethods">True if validating notsuportedMethods,
/// false otherwise</param>
void ValidateBAMFormatterWithSequenceAlignment(string nodeName,
BAMParserParameters BAMParserPam, bool WriteBAMIndexData,
bool IsNotSupportedMethods)
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
BAMIndexStorage BAMIndexStorageObj = null;
ISequenceAlignmentParser bamParserObj = new BAMParser();
try
{
using (BAMParser bamSeqMapParserObj = new BAMParser())
{
IEnumerable<ISequenceAlignment> seqList = bamParserObj.Parse(BAMStoragePath);
try
{
// Write BAm index data to BAM Index File.
if (WriteBAMIndexData)
{
BAMIndexStorageObj = new BAMIndexStorage(
File.Create(Constants.BAMTempIndexFileForSequenceAlignment));
}
// Create a BAM formatter object.
BAMFormatter formatterObj = new BAMFormatter
{
CreateSortedBAMFile = true,
CreateIndexFile = true
};
// Write/Format aligned sequences to BAM file.
switch (BAMParserPam)
{
case BAMParserParameters.StreamWriter:
try
{
using (var writer = File.Create(Constants.BAMTempFileName))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(writer, seq);
Assert.Fail();
}
}
}
catch (NotSupportedException ex)
{
string message = ex.Message;
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Formatter P1 : Validated the exception {0} successfully"
, message));
}
break;
case BAMParserParameters.Stream:
using (Stream stream = new
FileStream(Constants.BAMTempFileName,
FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(stream, seq);
}
}
File.Exists(Constants.BAMTempFileName);
break;
case BAMParserParameters.FileName:
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, Constants.BAMTempFileName);
}
File.Exists(Constants.BAMTempFileName);
break;
case BAMParserParameters.StreamAndIndexFile:
using (Stream stream = new
FileStream(Constants.BAMTempFileName,
FileMode.Create, FileAccess.ReadWrite))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(stream, BAMIndexStorageObj, seq);
}
}
File.Exists(Constants.BAMTempFileName);
break;
case BAMParserParameters.IndexFile:
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, Constants.BAMTempFileName,
Constants.BAMTempIndexFile);
}
File.Exists(Constants.BAMTempFileName);
break;
default:
break;
}
if (!IsNotSupportedMethods)
{
// Parse formatted BAM file and validate aligned sequences.
SequenceAlignmentMap expectedSeqAlignmentMap = bamSeqMapParserObj.ParseOne<SequenceAlignmentMap>(
Constants.BAMTempFileName);
IList<SAMAlignedSequence> alignedSeqs = expectedSeqAlignmentMap.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected sequences
FastAParser 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.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((IFormatProvider)null,
"BAM Formatter P1 : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
}
finally
{
if (BAMIndexStorageObj != null)
BAMIndexStorageObj.Dispose();
}
}
}
finally
{
(bamParserObj as BAMParser).Dispose();
File.Delete(Constants.BAMTempFileName);
File.Delete(Constants.BAMTempIndexFile);
}
}
/// <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">Different Parser parameters used for different testcases</param>
void ValidateBAMParserForQualitySequences(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedQualitySeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
string alignedSeqCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlignedSeqCountNode);
SequenceAlignmentMap seqAlignment = null;
BAMParser bamParser = new BAMParser();
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.FileName:
seqAlignment = bamParser.ParseOne<SequenceAlignmentMap>(BAMStoragePath);
break;
case BAMParserParameters.StreamReader:
using (Stream stream = new FileStream(BAMStoragePath, FileMode.Open,
FileAccess.Read))
{
seqAlignment = bamParser.ParseOne(stream);
}
break;
default:
break;
}
// Validate Aligned sequence CIGAR,QName and Bin index values.
this.ValidateAlignedSeqValues(nodeName, seqAlignment);
IList<SAMAlignedSequence> alignedSeqs = seqAlignment.QuerySequences;
Assert.AreEqual(alignedSeqCount, alignedSeqs.Count.ToString((IFormatProvider)null));
// Get expected quality sequences
FastAParser parserObj = new FastAParser();
IEnumerable<ISequence> expectedQualitySequences = parserObj.Parse(expectedQualitySeqFilePath);
IList<ISequence> expectedSequencesList = expectedQualitySequences.ToList();
// Validate quality sequences from BAM file.
for (int index = 0; index < alignedSeqs.Count; index++)
{
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((IFormatProvider)null,
"BAM Parser P1 : Validated Quality sequence :{0} successfully",
alignedSeqs[index].QuerySequence.ToString()));
}
}
/// <summary>
/// Parse BAM and validate parsed aligned sequences by creating
/// ISequenceAlignment interface object and its properties.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
/// <param name="BAMParserPam">BAM Parse method parameters</param>
void ValidateISequenceAlignmentBAMParser(string nodeName,
BAMParserParameters BAMParserPam)
{
// Get input and output values from xml node.
string BAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string expectedAlignedSeqFilePath = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
IEnumerable<ISequenceAlignment> seqAlignmentList = null;
ISequenceAlignmentParser bamParser = null;
ISequenceAlignment seqAlignment = null;
IList<IAlignedSequence> alignedSeqs = null;
bamParser = new BAMParser();
// Parse a BAM file with different parameters.
switch (BAMParserPam)
{
case BAMParserParameters.FileName:
seqAlignmentList = bamParser.Parse(BAMStoragePath);
alignedSeqs = seqAlignmentList.First().AlignedSequences;
break;
case BAMParserParameters.ParseOne:
seqAlignment = bamParser.ParseOne(File.OpenRead(BAMStoragePath));
alignedSeqs = seqAlignment.AlignedSequences;
break;
default:
break;
}
// Get expected sequences
FastAParser 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.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignedSeqs[index].Sequences[0].Select(a => (char)a).ToArray()));
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser P1 : Validated Aligned sequence :{0} successfully",
alignedSeqs[index].Sequences.ToString()));
}
}