| public Format ( Stream writer, Bio.IO.BAM.BAMIndexStorage indexWriter, ISequenceAlignment sequenceAlignment ) : void | ||
| writer | Stream | Stream to write BAM data. |
| indexWriter | Bio.IO.BAM.BAMIndexStorage | BAMIndexFile to write index data. |
| sequenceAlignment | ISequenceAlignment | SequenceAlignmentMap object. |
| return | void | |
/// <summary>
/// Write out the given SequenceAlignmentMap to the file
/// </summary>
/// <param name="formatter">BAMFormatter</param>
/// <param name="sam">SequenceAlignmentMap</param>
/// <param name="filename">File to write to</param>
public static void Format(this BAMFormatter formatter, SequenceAlignmentMap sam, string filename)
{
if (formatter == null)
{
throw new ArgumentNullException("formatter");
}
if (sam == null)
{
throw new ArgumentNullException("sam");
}
if (string.IsNullOrWhiteSpace(filename))
{
throw new ArgumentNullException("filename");
}
using (var fs = File.Create(filename))
{
// Create the IndexFile if necessary
if (formatter.CreateIndexFile)
{
using (var bamIndexFile = new BAMIndexStorage(
File.Create(filename + Properties.Resource.BAM_INDEXFILEEXTENSION)))
{
formatter.Format(fs, bamIndexFile, sam);
}
}
else
{
formatter.Format(fs, sam);
}
}
}
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();
}
}
/// <summary>
/// Write out the given SequenceAlignmentMap to the file
/// </summary>
/// <param name="formatter">BAMFormatter</param>
/// <param name="sam">SequenceAlignmentMap</param>
/// <param name="filename">File to write to</param>
/// <param name="indexFilename">BAM index file</param>
public static void Format(this BAMFormatter formatter, ISequenceAlignment sam, string filename, string indexFilename)
{
if (formatter == null)
{
throw new ArgumentNullException("formatter");
}
if (sam == null)
{
throw new ArgumentNullException("sam");
}
if (string.IsNullOrWhiteSpace(filename))
{
throw new ArgumentNullException("filename");
}
if (string.IsNullOrWhiteSpace(indexFilename))
{
throw new ArgumentNullException("indexFilename");
}
if (filename == indexFilename)
{
throw new ArgumentException("Use different filenames for index and alignment.", "indexFilename");
}
using (var fs = File.Create(filename))
using (var bamIndexFile = new BAMIndexStorage(File.Create(indexFilename)))
{
formatter.Format(fs, bamIndexFile, sam);
}
}
public void TestFormatter()
{
const string filePath = @"TestUtils\BAM\SeqAlignment.bam";
const string outputfilePath = "BAMTests123.bam";
string outputIndexFile = outputfilePath + ".bai";
BAMParser parser = new BAMParser();
SequenceAlignmentMap alignmentMap = parser.ParseOne<SequenceAlignmentMap>(filePath);
Assert.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.IsNotNull(alignmentMap.QuerySequences);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 2);
BAMFormatter formatter = new BAMFormatter();
formatter.Format(alignmentMap, outputfilePath);
formatter.CreateSortedBAMFile = true;
formatter.CreateIndexFile = true;
formatter.Format(alignmentMap, outputfilePath);
Assert.IsTrue(File.Exists("BAMTests123.bam.bai"));
alignmentMap = parser.ParseOne<SequenceAlignmentMap>(outputfilePath);
Assert.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
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.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
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.IsNotNull(alignmentMap);
Assert.IsNotNull(alignmentMap.Header);
Assert.AreEqual(alignmentMap.Header.GetReferenceSequencesInfoFromSQHeader().Count, 1);
Assert.AreEqual(alignmentMap.Header.ReferenceSequences.Count, 1);
Assert.AreEqual(alignmentMap.QuerySequences.Count, 1);
File.Delete(outputfilePath);
File.Delete(outputIndexFile);
}
/// <summary>
/// Public method to sort BAM file.
/// SAMUtil.exe in.bam out.bam
/// </summary>
public void DoSort()
{
string sortExtension = ".sort";
if (string.IsNullOrEmpty(InputFilename))
{
throw new InvalidOperationException(Resources.SortHelp);
}
BAMParser parse = new BAMParser();
SequenceAlignmentMap map = null;
try
{
map = parse.ParseOne<SequenceAlignmentMap>(InputFilename);
}
catch(Exception ex)
{
throw new InvalidOperationException(Resources.InvalidBAMFile, ex);
}
BAMFormatter format = new BAMFormatter
{
CreateSortedBAMFile = true,
SortType =
this.SortByReadName
? BAMSortByFields.ReadNames
: BAMSortByFields.ChromosomeCoordinates
};
if (string.IsNullOrEmpty(OutputFilename))
{
OutputFilename = InputFilename + sortExtension;
autoGeneratedOutputFilename = true;
}
format.Format(map, OutputFilename);
if (autoGeneratedOutputFilename)
{
Console.WriteLine(Resources.SuccessMessageWithOutputFileName, OutputFilename);
}
}
/// <summary>
/// Writes the SAM object to file in SAM/BAM format.
/// </summary>
private void PerformFormat()
{
if (_isSAM)
{
BAMFormatter format = new BAMFormatter();
try
{
format.Format(_sequenceAlignmentMap, OutputFilename);
}
catch (Exception ex)
{
throw new InvalidOperationException(Resources.WriteBAM + Environment.NewLine + ex.Message);
}
}
else
{
SAMFormatter format = new SAMFormatter();
try
{
format.Format(_sequenceAlignmentMap, OutputFilename);
}
catch (Exception ex)
{
throw new InvalidOperationException(Resources.WriteSAM + Environment.NewLine + ex.Message);
}
}
}
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>
/// 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);
}
public void ValidateSAMToBAMConversion()
{
// Get values from xml config file.
string expectedBamFilePath = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMToSAMConversionNode, Constants.FilePathNode);
string samFilePath = this.utilityObj.xmlUtil.GetTextValue(
Constants.BAMToSAMConversionNode, Constants.FilePathNode1);
// Parse expected BAM file.
var bamParserObj = new BAMParser();
SequenceAlignmentMap expextedBamAlignmentObj = bamParserObj.ParseOne<SequenceAlignmentMap>(expectedBamFilePath);
// Parse a SAM file.
var samParserObj = new SAMParser();
SequenceAlignmentMap samSeqAlignment = samParserObj.ParseOne<SequenceAlignmentMap>(samFilePath);
try
{
// Format SAM sequenceAlignment object to BAM file.
var bamFormatterObj = new BAMFormatter();
bamFormatterObj.Format(samSeqAlignment, Constants.BAMTempFileName);
// Parse a formatted BAM file.
SequenceAlignmentMap bamSeqAlignment = bamParserObj.ParseOne<SequenceAlignmentMap>(Constants.BAMTempFileName);
// Validate converted BAM file with expected BAM file.
Assert.IsTrue(CompareSequencedAlignmentHeader(bamSeqAlignment, expextedBamAlignmentObj));
// Validate BAM file aligned sequences.
Assert.IsTrue(CompareAlignedSequences(bamSeqAlignment, expextedBamAlignmentObj));
}
finally
{
// Delete temporary file.
File.Delete(Constants.BAMTempFileName);
}
}
/// <summary>
/// Invalidate BAMFormatter with null values.
/// </summary>
/// <param name="formatterObj">Bam formatter obj</param>
/// <param name="seqList">List of sequences</param>
private static void InvalidateBAmFormatterWithWithNullValues(BAMFormatter formatterObj,
IList<ISequenceAlignment> seqList)
{
try
{
using (Stream stream = new
FileStream(Constants.BAMTempFileName,
FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(stream, null, seq);
}
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully",
ex.Message));
}
// Invalidate Format(IseqAlignment, StreamWriter)
try
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(null as Stream, seq);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully",
ex.Message));
}
try
{
using (Stream stream = new
FileStream(Constants.BAMTempFileName,
FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, null as ISequenceAlignment);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully",
ex.Message));
}
}
/// <summary>
/// Invalidate BAMFormatter.
/// </summary>
/// <param name="formatterObj">Bam formatter obj</param>
/// <param name="seqList">List of sequences</param>
private static void InvalidateBAmFormatter(BAMFormatter formatterObj,
IList<ISequenceAlignment> seqList)
{
// Invalidate BAM Parser Format(SeqAlignment, BamFileName)
try
{
formatterObj.Format(null as ISequenceAlignment,
Constants.BAMTempFileName);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, null as string);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate Format(IseqAlignment, BAMFile, IndexFile)
try
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, null,
Constants.BAMTempIndexFileForIndexData);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
foreach (ISequenceAlignment seq in seqList)
{
formatterObj.Format(seq, Constants.BAMTempFileName,
Constants.BAMTempFileName);
}
}
catch (ArgumentException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
}
/// <summary>
/// Format BAM file and validate.
/// </summary>
/// <param name="nodeName">Different xml nodes used for different test cases</param>
private void InValidateBAMFormatter(string nodeName)
{
// Get input and output values from xml node.
string bamFilePath = _utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode);
using (var bamParserObj = new BAMParser())
{
using (var storage = new BAMIndexStorage(File.Create(Constants.BAMTempIndexFileForIndexData)))
{
// Parse a BAM file.
var seqAlignment = bamParserObj.ParseOne <SequenceAlignmentMap>(bamFilePath);
// Create a BAM formatter object.
var formatterObj = new BAMFormatter();
// Null filename
try
{
formatterObj.Format(seqAlignment, null, Constants.BAMTempIndexFileForIndexData);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Same filename
try
{
formatterObj.Format(seqAlignment, Constants.BAMTempFileName, Constants.BAMTempFileName);
}
catch (ArgumentException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Null sequence
try
{
formatterObj.Format(null, bamFilePath, Constants.BAMTempIndexFileForIndexData);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Null index
try
{
formatterObj.Format(seqAlignment, bamFilePath, null);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate BAM Parser Format(SeqAlignmentMap, BamFileName)
try
{
formatterObj.Format(null as SequenceAlignmentMap,
Constants.BAMTempFileName);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
formatterObj.Format(seqAlignment, null as string);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate Format(SequenceAlignmentMap, StreamWriter)
try
{
formatterObj.Format(null, seqAlignment);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
Stream stream;
try
{
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, null as ISequenceAlignment);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
// Invalidate Format(SequenceAlignmentMap, StreamWriter, IndexFile)
try
{
formatterObj.Format(null, storage, seqAlignment);
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, storage, null);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
try
{
using (stream = new FileStream(Constants.BAMTempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
formatterObj.Format(stream, null, seqAlignment);
}
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine(string.Format("BAM Parser P2 : Validated Exception {0} successfully", ex.Message));
}
formatterObj = null;
}
}
}
/// <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>
/// Validate SAM to BAM conversion.
/// </summary>
/// <param name="nodeName">Different xml node name used for different test cases</param>
void ValidateSAMToBAMConversion(string nodeName)
{
// Get values from xml config file.
string expectedBAMStoragePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string samFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode1);
BAMParser bamParserObj = new BAMParser();
SAMParser samParserObj = new SAMParser();
BAMFormatter bamFormatterObj = new BAMFormatter { CreateSortedBAMFile = true, CreateIndexFile = true };
SequenceAlignmentMap samSeqAlignment = null;
SequenceAlignmentMap bamSeqAlignment = null;
// Parse expected BAM file.
SequenceAlignmentMap expextedBamAlignmentObj = bamParserObj.ParseOne<SequenceAlignmentMap>(expectedBAMStoragePath);
// Parse a SAM file.
samSeqAlignment = samParserObj.ParseOne<SequenceAlignmentMap>(samFilePath);
try
{
// Format SAM sequenceAlignment object to BAM file.
bamFormatterObj.Format(samSeqAlignment, Constants.BAMTempFileName);
// Parse a formatted BAM file.
bamSeqAlignment = bamParserObj.ParseOne<SequenceAlignmentMap>(Constants.BAMTempFileName);
// Validate converted BAM file with expected BAM file.
Assert.IsTrue(CompareSequencedAlignmentHeader(bamSeqAlignment,
expextedBamAlignmentObj));
// Validate BAM file aligned sequences.
Assert.IsTrue(CompareAlignedSequences(bamSeqAlignment,
expextedBamAlignmentObj));
// Log message to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser P1 : Validated the SAM->BAM conversion successfully"));
}
finally
{
// Delete temporary file.
File.Delete(Constants.BAMTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
}