/// <summary>
/// Validate formatter all format method overloads with filePath\textwriter
/// </summary>
/// <param name="nodeName">xml node name</param>
/// <param name="formatTypes">enum type to execute different overload</param>
void ValidateSAMFormatter(string nodeName,
ParseOrFormatTypes formatTypes)
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string expectedSequenceFile = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
ISequenceAlignmentParser parser = new SAMParser();
try
{
IList <ISequenceAlignment> alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
switch (formatTypes)
{
case ParseOrFormatTypes.ParseOrFormatText:
using (TextWriter writer =
new StreamWriter(Constants.SAMTempFileName))
{
formatter.Format(alignments[0], writer);
}
break;
case ParseOrFormatTypes.ParseOrFormatFileName:
formatter.Format(alignments[0], Constants.SAMTempFileName);
break;
}
alignments = parser.Parse(Constants.SAMTempFileName);
// Get expected sequences
using (FastAParser parserObj = new FastAParser(expectedSequenceFile))
{
IEnumerable <ISequence> expectedSequences = parserObj.Parse();
IList <ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate parsed output with expected output
int count = 0;
for (int index = 0; index < alignments.Count; index++)
{
for (int ialigned = 0; ialigned <
alignments[index].AlignedSequences.Count; ialigned++)
{
for (int iseq = 0; iseq <
alignments[index].AlignedSequences[ialigned].Sequences.Count; iseq++)
{
Assert.AreEqual(new string(expectedSequencesList[count].Select(a => (char)a).ToArray()),
new string(alignments[index].AlignedSequences[ialigned].Sequences[iseq].Select(a => (char)a).ToArray()));
count++;
}
}
}
}
}
finally
{
(parser as SAMParser).Dispose();
}
}
/// <summary>
/// General method to validate SAM Formatter method.
/// </summary>
/// <param name="nodeName">xml node name</param>
/// <param name="parseTypes">enum type to execute different overload</param>
void ValidateSAMFormatterSeqAlign(
string nodeName,
ParseOrFormatTypes parseTypes)
{
// Gets the expected sequence from the Xml
string filePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string expectedSequenceFile = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
using (SAMParser parser = new SAMParser())
{
SequenceAlignmentMap alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
switch (parseTypes)
{
case ParseOrFormatTypes.ParseOrFormatText:
using (TextWriter writer =
new StreamWriter(Constants.SAMTempFileName))
{
formatter.Format(alignments, writer);
}
break;
case ParseOrFormatTypes.ParseOrFormatFileName:
formatter.Format(alignments, Constants.SAMTempFileName);
break;
case ParseOrFormatTypes.ParseOrFormatFileNameWithFlag:
formatter.Format(alignments, Constants.SAMTempFileName);
break;
}
alignments = parser.Parse(Constants.SAMTempFileName);
// Get expected sequences
using (FastaParser parserObj = new FastaParser())
{
IList <ISequence> expectedSequences =
parserObj.Parse(expectedSequenceFile);
// Validate parsed output with expected output
for (int index = 0;
index < alignments.QuerySequences.Count;
index++)
{
for (int count = 0;
count < alignments.QuerySequences[index].Sequences.Count;
count++)
{
Assert.AreEqual(expectedSequences[index].ToString(),
alignments.QuerySequences[index].Sequences[count].ToString());
}
}
}
}
}
/// <summary>
/// Validate formatter all format method overloads with filePath\textwriter
/// </summary>
/// <param name="nodeName">xml node name</param>
/// <param name="formatTypes">enum type to execute different overload</param>
void ValidateSAMFormatter(string nodeName,
ParseOrFormatTypes formatTypes)
{
// Gets the expected sequence from the Xml
string filePath = Utility._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string expectedSequenceFile = Utility._xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
ISequenceAlignmentParser parser = new SAMParser();
IList <ISequenceAlignment> alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
switch (formatTypes)
{
case ParseOrFormatTypes.ParseOrFormatText:
using (TextWriter writer =
new StreamWriter(Constants.SAMTempFileName))
{
formatter.Format(alignments[0], writer);
}
break;
case ParseOrFormatTypes.ParseOrFormatFileName:
formatter.Format(alignments[0], Constants.SAMTempFileName);
break;
case ParseOrFormatTypes.ParseOrFormatFileNameWithFlag:
formatter.Format(alignments, Constants.SAMTempFileName);
break;
}
alignments = parser.Parse(Constants.SAMTempFileName);
// Get expected sequences
FastaParser parserObj = new FastaParser();
IList <ISequence> expectedSequences = parserObj.Parse(expectedSequenceFile);
// Validate parsed output with expected output
int count = 0;
for (int index = 0; index < alignments.Count; index++)
{
for (int ialigned = 0; ialigned <
alignments[index].AlignedSequences.Count; ialigned++)
{
for (int iseq = 0; iseq <
alignments[index].AlignedSequences[ialigned].Sequences.Count; iseq++)
{
Assert.AreEqual(expectedSequences[count].ToString(),
alignments[index].AlignedSequences[ialigned].Sequences[iseq].ToString());
count++;
}
}
}
}
/// <summary>
/// General method to validate SAM Formatter method.
/// </summary>
/// <param name="nodeName">xml node name</param>
/// <param name="parseTypes">enum type to execute different overload</param>
void ValidateSAMFormatterSeqAlign(
string nodeName,
ParseOrFormatTypes parseTypes)
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode).TestDir();
string expectedSequenceFile = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence).TestDir();
SAMParser parser = new SAMParser();
{
SequenceAlignmentMap alignments = parser.ParseOne <SequenceAlignmentMap>(filePath);
SAMFormatter formatter = new SAMFormatter();
switch (parseTypes)
{
case ParseOrFormatTypes.ParseOrFormatText:
using (var writer =
File.Create(Constants.SAMTempFileName))
{
formatter.Format(writer, alignments);
}
break;
case ParseOrFormatTypes.ParseOrFormatFileName:
formatter.Format(alignments, Constants.SAMTempFileName);
break;
}
alignments = parser.ParseOne <SequenceAlignmentMap>(Constants.SAMTempFileName);
// Get expected sequences
FastAParser parserObj = new FastAParser();
{
IEnumerable <ISequence> expectedSequences =
parserObj.Parse(expectedSequenceFile);
IList <ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate parsed output with expected output
for (int index = 0;
index < alignments.QuerySequences.Count;
index++)
{
for (int count = 0;
count < alignments.QuerySequences[index].Sequences.Count;
count++)
{
Assert.AreEqual(new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignments.QuerySequences[index].Sequences[count].Select(a => (char)a).ToArray()));
}
}
}
}
}
public void ValidateSAMFormatterWithTextWriterAndAlignments()
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSAMFileNode, Constants.FilePathNode);
ISequenceAlignmentParser parser = new SAMParser();
try
{
IList <ISequenceAlignment> alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
try
{
using (TextWriter writer =
new StreamWriter(Constants.SAMTempFileName))
{
formatter.Format(alignments, writer);
}
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"SAM Parser BVT : Validated the exception successfully"));
Console.WriteLine(string.Format((IFormatProvider)null,
"SAM Parser BVT : Validated the exception successfully"));
}
}
finally
{
(parser as SAMParser).Dispose();
}
}
/// <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);
}
}
}
/// <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, _outputFile);
}
catch
{
throw new InvalidOperationException(Resources.WriteBAM);
}
}
else
{
SAMFormatter format = new SAMFormatter();
try
{
format.Format(_sequenceAlignmentMap, _outputFile);
}
catch
{
throw new InvalidOperationException(Resources.WriteSAM);
}
}
}
public void TestFormatter()
{
string filePath = @"TestUtils\SAM\SeqAlignment1.sam".TestDir();
string outputfilePath = "samtest.sam";
ISequenceAlignmentParser parser = new SAMParser();
IList <ISequenceAlignment> alignments = parser.Parse(filePath).ToList();
Assert.IsTrue(alignments != null);
Assert.AreEqual(alignments.Count, 1);
Assert.AreEqual(alignments[0].AlignedSequences.Count, 2);
try
{
SAMFormatter formatter = new SAMFormatter();
formatter.Format(alignments[0], outputfilePath);
alignments = parser.Parse(outputfilePath).ToList();
Assert.IsTrue(alignments != null);
Assert.AreEqual(alignments.Count, 1);
Assert.AreEqual(alignments[0].AlignedSequences.Count, 2);
}
finally
{
File.Delete(outputfilePath);
}
}
public void ValidateBAMToSAMConversionWithDVEnabled()
{
// Get values from xml config file.
string expectedSamFilePath = _utilityObj._xmlUtil.GetTextValue(Constants.BAMToSAMConversionNode,
Constants.FilePathNode1);
string bamFilePath = _utilityObj._xmlUtil.GetTextValue(Constants.BAMToSAMConversionNode,
Constants.FilePathNode);
using (BAMParser bamParserObj = new BAMParser())
{
using (SAMParser samParserObj = new SAMParser())
{
SAMFormatter samFormatterObj = new SAMFormatter();
SequenceAlignmentMap samSeqAlignment = null;
SequenceAlignmentMap bamSeqAlignment = null;
// Parse expected SAM file.
SequenceAlignmentMap expextedSamAlignmentObj = samParserObj.Parse(
expectedSamFilePath);
// Parse a BAM file.
bamParserObj.EnforceDataVirtualization = true;
bamSeqAlignment = bamParserObj.Parse(bamFilePath);
// Format BAM sequenceAlignment object to SAM file.
samFormatterObj.Format(bamSeqAlignment, Constants.SAMTempFileName);
// Parse a formatted SAM file.
samSeqAlignment = samParserObj.Parse(Constants.SAMTempFileName);
// Validate converted SAM file with expected SAM file.
Assert.IsTrue(CompareSequencedAlignmentHeader(samSeqAlignment, expextedSamAlignmentObj));
// Validate SAM file aligned sequences.
Assert.IsTrue(CompareAlignedSequences(samSeqAlignment, expextedSamAlignmentObj));
}
}
// Log message to NUnit GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated the BAM->SAM conversion successfully"));
Console.WriteLine(string.Format((IFormatProvider)null,
"BAM Parser BVT : Validated the BAM->SAM conversion successfully"));
// Delete temporary file.
File.Delete(Constants.SAMTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
/// <summary>
/// General method to validate SAM Formatter method.
/// </summary>
/// <param name="nodeName">xml node name</param>
/// <param name="parseTypes">enum type to execute different overload</param>
void ValidateSAMFormatter(string nodeName)
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string expectedSequenceFile = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
using (SAMParser parser = new SAMParser())
{
SequenceAlignmentMap alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
using (TextWriter writer =
new StreamWriter(Constants.SAMTempFileName))
{
formatter.Format(alignments, writer);
}
alignments = parser.Parse(Constants.SAMTempFileName);
// Get expected sequences
using (FastAParser parserObj = new FastAParser(expectedSequenceFile))
{
IEnumerable <ISequence> expectedSequences =
parserObj.Parse();
IList <ISequence> expectedSequencesList = expectedSequences.ToList();
// Validate parsed output with expected output
for (int index = 0;
index < alignments.QuerySequences.Count;
index++)
{
for (int count = 0;
count < alignments.QuerySequences[index].Sequences.Count;
count++)
{
Assert.AreEqual(
new string(expectedSequencesList[index].Select(a => (char)a).ToArray()),
new string(alignments.QuerySequences[index].Sequences[count].Select(a => (char)a).ToArray()));
}
}
}
}
}
public void ValidateSAMFormatterWithFileNameAndAlignments()
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSAMFileNode.Replace("\r\n", System.Environment.NewLine), Constants.FilePathNode);
ISequenceAlignmentParser parser = new SAMParser();
IEnumerable <ISequenceAlignment> alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
try
{
formatter.Format(alignments, Constants.SAMTempFileName);
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine("SAM Parser BVT : Validated the exception successfully");
}
}
public void TestFormatter()
{
string filePath = @"TestData\SAM\SeqAlignment1.sam";
string outputfilePath = "samtest.sam";
ISequenceAlignmentParser parser = new SAMParser();
SAMFormatter formatter = new SAMFormatter();
IList <ISequenceAlignment> alignments = parser.Parse(filePath);
Assert.IsTrue(alignments != null);
Assert.AreEqual(alignments.Count, 1);
Assert.AreEqual(alignments[0].AlignedSequences.Count, 2);
formatter.Format(alignments[0], outputfilePath);
alignments = parser.Parse(outputfilePath);
Assert.IsTrue(alignments != null);
Assert.AreEqual(alignments.Count, 1);
Assert.AreEqual(alignments[0].AlignedSequences.Count, 2);
}
public void ValidateSAMFormatterWithFileNameAndAlignments()
{
// Gets the expected sequence from the Xml
string filePath = Utility._xmlUtil.GetTextValue(
Constants.SmallSAMFileNode, Constants.FilePathNode);
ISequenceAlignmentParser parser = new SAMParser();
IList <ISequenceAlignment> alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
try
{
formatter.Format(alignments, Constants.SAMTempFileName);
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine(string.Format(null,
"SAM Parser BVT : Validated the exception successfully"));
Console.WriteLine(string.Format(null,
"SAM Parser BVT : Validated the exception successfully"));
}
}
public void ValidateSAMFormatterWithTextWriterAndAlignments()
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSAMFileNode, Constants.FilePathNode);
ISequenceAlignmentParser parser = new SAMParser();
IEnumerable <ISequenceAlignment> alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
try
{
using (var writer = File.Create(Constants.SAMTempFileName))
{
formatter.Format(writer, alignments);
}
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine("SAM Parser BVT : Validated the exception successfully");
}
}
/// <summary>
/// General method to validate SAM Formatter method.
/// </summary>
/// <param name="nodeName">xml node name</param>
/// <param name="parseTypes">enum type to execute different overload</param>
void ValidateSAMFormatter(string nodeName)
{
// Gets the expected sequence from the Xml
string filePath = Utility._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string expectedSequenceFile = Utility._xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequence);
SAMParser parser = new SAMParser();
SequenceAlignmentMap alignments = parser.Parse(filePath);
SAMFormatter formatter = new SAMFormatter();
using (TextWriter writer =
new StreamWriter(Constants.SAMTempFileName))
{
formatter.Format(alignments, writer);
}
alignments = parser.Parse(Constants.SAMTempFileName);
// Get expected sequences
FastaParser parserObj = new FastaParser();
IList <ISequence> expectedSequences =
parserObj.Parse(expectedSequenceFile);
// Validate parsed output with expected output
for (int index = 0;
index < alignments.QuerySequences.Count;
index++)
{
for (int count = 0;
count < alignments.QuerySequences[index].Sequences.Count;
count++)
{
Assert.AreEqual(expectedSequences[index].ToString(),
alignments.QuerySequences[index].Sequences[count].ToString());
}
}
}
