public void ValidateSeqFormatterProperties()
{
// Gets the expected sequence from the Xml
string fastaFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.FastAFileParserNode,
Constants.ParserNameNode);
string genBankFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.GenBankFileParserNode,
Constants.ParserNameNode);
string gffFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.GffFileParserNode,
Constants.ParserNameNode);
string fastQFormatterName = this.utilityObj.xmlUtil.GetTextValue(Constants.FastQFileParserNode,
Constants.ParserNameNode);
// Get SequenceFormatter class properties.
FastAFormatter actualFastAFormatter = SequenceFormatters.Fasta;
IReadOnlyList <ISequenceFormatter> allFormatters = SequenceFormatters.All;
GenBankFormatter actualgenBankFormatterName = SequenceFormatters.GenBank;
FastQFormatter actualFastQFormatterName = SequenceFormatters.FastQ;
GffFormatter actualGffFormatterName = SequenceFormatters.Gff;
// Validate Sequence Formatter
Assert.AreEqual(fastaFormatterName, actualFastAFormatter.Name);
Assert.AreEqual(genBankFormatterName, actualgenBankFormatterName.Name);
Assert.AreEqual(gffFormatterName, actualGffFormatterName.Name);
Assert.AreEqual(fastQFormatterName, actualFastQFormatterName.Name);
Assert.IsNotNull(allFormatters);
ApplicationLog.WriteLine("Type of the parser is validated successfully");
}
public void ValidateSeqFormatterProperties()
{
// Gets the expected sequence from the Xml
string fastaFormatterName = _utilityObj._xmlUtil.GetTextValue(Constants.FastAFileParserNode,
Constants.ParserNameNode);
string genBankFormatterName = _utilityObj._xmlUtil.GetTextValue(Constants.GenBankFileParserNode,
Constants.ParserNameNode);
string gffFormatterName = _utilityObj._xmlUtil.GetTextValue(Constants.GffFileParserNode,
Constants.ParserNameNode);
string fastQFormatterName = _utilityObj._xmlUtil.GetTextValue(Constants.FastQFileParserNode,
Constants.ParserNameNode);
// Get SequenceFormatter class properties.
FastaFormatter actualFastAFormatter = SequenceFormatters.Fasta;
IList <ISequenceFormatter> allFormatters = SequenceFormatters.All;
GenBankFormatter actualgenBankFormatterName = SequenceFormatters.GenBank;
FastQFormatter actualFastQFormatterName = SequenceFormatters.FastQ;
GffFormatter actualGffFormatterName = SequenceFormatters.Gff;
// Validate Sequence Formatter
Assert.AreEqual(fastaFormatterName, actualFastAFormatter.Name);
Assert.AreEqual(4, allFormatters.Count);
Assert.AreEqual(genBankFormatterName, actualgenBankFormatterName.Name);
Assert.AreEqual(gffFormatterName, actualGffFormatterName.Name);
Assert.AreEqual(fastQFormatterName, actualFastQFormatterName.Name);
Console.WriteLine(string.Format((IFormatProvider)null,
"SequenceFormatter : Type of the parser is validated successfully"));
ApplicationLog.WriteLine("Type of the parser is validated successfully");
}
/// <summary>
/// Returns formatter which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the formatter is required.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByFile(string fileName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (Helper.IsGenBank(fileName))
{
formatter = new GenBankFormatter();
}
else if (fileName.EndsWith(Resource.GFF_FILEEXTENSION, StringComparison.InvariantCultureIgnoreCase))
{
formatter = new GffFormatter();
}
else if (Helper.IsFasta(fileName))
{
formatter = new FastaFormatter();
}
else if (Helper.IsFastQ(fileName))
{
formatter = new FastQFormatter();
}
else
{
formatter = null;
}
}
return(formatter);
}
/// <summary>
/// Returns parser which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the parser is required.</param>
/// <param name="formatterName">Name of the formatter to use.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByName(string fileName, string formatterName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (formatterName == Properties.Resource.FastAName)
{
formatter = new FastAFormatter(fileName);
}
else if (formatterName == Properties.Resource.FastQName)
{
formatter = new FastQFormatter(fileName);
}
else if (formatterName == Properties.Resource.GENBANK_NAME)
{
formatter = new GenBankFormatter(fileName);
}
else if (formatterName == Properties.Resource.GFF_NAME)
{
formatter = new GffFormatter(fileName);
}
else
{
formatter = null;
}
}
return(formatter);
}
/// <summary>
/// Filters GTF or GFF entries that lack strand information
/// Can filter also by zero abundance stringtie estimates
/// Add CDS at the end
/// </summary>
/// <param name="gtfPath"></param>
/// <param name="gtfOutPath"></param>
public static void FilterGtfEntriesWithoutStrand(string gtfPath, string referenceGenomePath, string referenceGeneModelPath, bool filterEntriesWithZeroAbundanceStringtieEstimates = false)
{
var chromFeatures = GeneModel.SimplerParse(gtfPath);
string filteredGtfPath = Path.Combine(Path.GetDirectoryName(gtfPath), Path.GetFileNameWithoutExtension(gtfPath) + ".filtered.gtf");
using (var file = File.Create(filteredGtfPath))
{
var formatter = new GffFormatter();
foreach (var chromISeq in chromFeatures)
{
List <MetadataListItem <List <string> > > filteredFeatures = new List <MetadataListItem <List <string> > >();
bool isMetadata = chromISeq.Metadata.TryGetValue("features", out object featuresObj);
if (isMetadata)
{
bool okayTranscript = false;
var features = featuresObj as List <MetadataListItem <List <string> > >;
foreach (var feature in features)
{
if (!feature.SubItems.TryGetValue("strand", out List <string> strandish))
{
continue;
}
var attributes = GeneModel.SplitAttributes(feature.FreeText);
if (feature.Key == "transcript")
{
bool okayFpkm = !filterEntriesWithZeroAbundanceStringtieEstimates ||
attributes.TryGetValue("FPKM", out string fpkm) && double.TryParse(fpkm, out double fpkmValue) && fpkmValue > 0;
bool okayTpm = !filterEntriesWithZeroAbundanceStringtieEstimates ||
attributes.TryGetValue("TPM", out string tpm) && double.TryParse(tpm, out double tpmValue) && tpmValue > 0;
okayTranscript = okayFpkm && okayTpm;
}
if (okayTranscript)
{
filteredFeatures.Add(feature);
}
}
}
chromISeq.Metadata["features"] = filteredFeatures;
}
formatter.Format(file, chromFeatures);
}
Genome ensemblGenome = new Genome(referenceGenomePath);
GeneModel newGeneModel = new GeneModel(ensemblGenome, filteredGtfPath);
GeneModel referenceGeneModel = new GeneModel(ensemblGenome, referenceGeneModelPath);
newGeneModel.CreateCDSFromAnnotatedStartCodons(referenceGeneModel);
string filteredGtfWithCdsPath = Path.Combine(Path.GetDirectoryName(filteredGtfPath), Path.GetFileNameWithoutExtension(filteredGtfPath) + ".withcds.gtf");
newGeneModel.PrintToGTF(filteredGtfWithCdsPath);
}
public void GffFormatterValidateOpen()
{
using (GffFormatter formatter = new GffFormatter())
{
try
{
formatter.Open(Constants.GffTempFileName);
}
catch (System.IO.IOException exception)
{
Assert.Fail("Exception thrown on opening a file " + exception.Message);
}
}
ApplicationLog.WriteLine("Opened the file successfully");
}
/// <summary>
/// Print out to a
/// </summary>
/// <param name="outGffFilePath"></param>
public void PrintToGTF(string outGffFilePath)
{
using (FileStream stream = new FileStream(outGffFilePath, FileMode.Create))
{
GffFormatter gff = new GffFormatter();
foreach (Chromosome chrom in Genome.Chromosomes)
{
if (GenomeForest.Forest.TryGetValue(chrom.FriendlyName, out var tree))
{
IEnumerable <Gene> genes = tree.Intervals.OfType <Gene>().OrderBy(g => g.OneBasedStart);
chrom.Sequence.Metadata["features"] = genes.SelectMany(g => g.GetFeatures()).ToList();
chrom.Sequence.ID = chrom.FriendlyName; // shortens to "1" from "1 dna:chromosome chromosome:GRCh37:1:1:249250621:1 REF"
gff.Format(stream, chrom.Sequence);
}
}
}
}
public void GffFormatterValidateFormatString()
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(Constants.SimpleGffNodeName,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePath));
IList <ISequence> seqs = null;
GffParser parserObj = new GffParser(filePath);
seqs = parserObj.Parse().ToList();
ISequence originalSequence = (Sequence)seqs[0];
// Use the formatter to write the original sequences to a temp file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: Creating the Temp file '{0}'.", Constants.GffTempFileName));
GffFormatter formatter = new GffFormatter();
formatter.ShouldWriteSequenceData = true;
string formatString = formatter.FormatString(originalSequence);
string expectedString = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleGffNodeName, Constants.FormatStringNode);
expectedString = expectedString.Replace("current-date",
DateTime.Today.ToString("yyyy-MM-dd", null));
expectedString =
expectedString.Replace("\r", "").Replace("\n", "").Replace(" ", "").Replace("\t", "").ToUpper(CultureInfo.CurrentCulture);
string modifedformatString =
formatString.Replace("\r", "").Replace("\n", "").Replace(" ", "").Replace("\t", "").ToUpper(CultureInfo.CurrentCulture);
Assert.AreEqual(modifedformatString, expectedString);
Console.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: The Gff Format String '{0}' are matching with FormatString() method and is as expected.",
formatString));
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: The Gff Format String '{0}' are matching with FormatString() method and is as expected.",
formatString));
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
File.Delete(Constants.GffTempFileName);
ApplicationLog.WriteLine("Deleted the temp file created.");
}
/// <summary>
/// Filters GTF or GFF entries that lack strand information
/// </summary>
/// <param name="gtfPath"></param>
/// <param name="gtfOutPath"></param>
public void FilterGtfEntriesWithoutStrand(string gtfPath, string gtfOutPath, bool filterEntriesWithZeroAbundanceStringtieEstimates)
{
var chromFeatures = GeneModel.SimplerParse(gtfPath);
//if (!File.Exists(gtfOutPath))
//{
using (var file = File.Create(gtfOutPath))
{
var formatter = new GffFormatter();
foreach (var chromISeq in chromFeatures)
{
List <MetadataListItem <List <string> > > filteredFeatures = new List <MetadataListItem <List <string> > >();
bool isMetadata = chromISeq.Metadata.TryGetValue("features", out object featuresObj);
if (isMetadata)
{
bool okayTranscript = false;
var features = featuresObj as List <MetadataListItem <List <string> > >;
foreach (var feature in features)
{
if (!feature.SubItems.TryGetValue("strand", out List <string> strandish))
{
continue;
}
var attributes = GeneModel.SplitAttributes(feature.FreeText);
if (feature.Key == "transcript")
{
bool okayFpkm = !filterEntriesWithZeroAbundanceStringtieEstimates ||
attributes.TryGetValue("FPKM", out string fpkm) && double.TryParse(fpkm, out double fpkmValue) && fpkmValue > 0;
bool okayTpm = !filterEntriesWithZeroAbundanceStringtieEstimates ||
attributes.TryGetValue("TPM", out string tpm) && double.TryParse(tpm, out double tpmValue) && tpmValue > 0;
okayTranscript = okayFpkm && okayTpm;
}
if (okayTranscript)
{
filteredFeatures.Add(feature);
}
}
}
chromISeq.Metadata["features"] = filteredFeatures;
}
formatter.Format(file, chromFeatures);
}
//}
}
/// <summary>
/// Returns formatter which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the formatter is required.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByFileName(string fileName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (IsFasta(fileName))
{
formatter = new FastAFormatter(fileName);
}
else if (IsFastQ(fileName))
{
formatter = new FastQFormatter(fileName);
}
else if (IsGenBank(fileName))
{
formatter = new GenBankFormatter(fileName);
}
else if (fileName.EndsWith(Properties.Resource.GFF_FILEEXTENSION, StringComparison.InvariantCultureIgnoreCase))
{
formatter = new GffFormatter(fileName);
}
else
{
// Do a search through the known formatters to pick up custom formatters added through add-in.
string fileExtension = Path.GetExtension(fileName);
if (!string.IsNullOrEmpty(fileExtension))
{
formatter = All.FirstOrDefault(p => p.SupportedFileTypes.Contains(fileExtension));
// If we found a match based on extension, then open the file - this
// matches the above behavior where a specific formatter was created for
// the passed filename - the formatter is opened automatically in the constructor.
if (formatter != null)
{
formatter.Open(fileName);
}
}
}
}
return(formatter);
}
/// <summary>
/// Returns parser which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the parser is required.</param>
/// <param name="formatterName">Name of the formatter to use.</param>
/// <returns>If found returns the formatter as ISequenceFormatter else returns null.</returns>
public static ISequenceFormatter FindFormatterByName(string fileName, string formatterName)
{
ISequenceFormatter formatter = null;
if (!string.IsNullOrEmpty(fileName))
{
if (formatterName == Properties.Resource.FastAName)
{
formatter = new FastAFormatter(fileName);
}
else if (formatterName == Properties.Resource.FastQName)
{
formatter = new FastQFormatter(fileName);
}
else if (formatterName == Properties.Resource.GENBANK_NAME)
{
formatter = new GenBankFormatter(fileName);
}
else if (formatterName == Properties.Resource.GFF_NAME)
{
formatter = new GffFormatter(fileName);
}
else
{
// Do a search through the known formatters to pick up custom formatters added through add-in.
formatter = All.FirstOrDefault(p => p.Name == formatterName);
// If we found a match based on extension, then open the file - this
// matches the above behavior where a specific formatter was created for
// the passed filename - the formatter is opened automatically in the constructor.
if (formatter != null)
{
formatter.Open(fileName);
}
}
}
return(formatter);
}
/// <summary>
/// Validates the Format() method in Gff Formatter based on the parameters.
/// </summary>
/// <param name="nodeName">Xml Node name to be read.</param>
/// <param name="isFilePath">Is file path passed as parameter?</param>
/// <param name="isSequenceList">Is sequence list passed as parameter?</param>
void ValidateFormatGeneralTestCases(string nodeName,
bool isFilePath, bool isSequenceList)
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePath));
IList <ISequence> seqs = null;
GffParser parserObj = new GffParser(filePath);
seqs = parserObj.Parse().ToList();
Sequence originalSequence = (Sequence)seqs[0];
// Use the formatter to write the original sequences to a temp file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: Creating the Temp file '{0}'.",
Constants.GffTempFileName));
GffFormatter formatter = new GffFormatter(Constants.GffTempFileName);
formatter.ShouldWriteSequenceData = true;
if (isFilePath)
{
if (isSequenceList)
{
formatter.Write(seqs);
}
else
{
formatter.Write(originalSequence);
}
}
else
{
if (isSequenceList)
{
formatter.Write(seqs);
}
else
{
formatter.Write(originalSequence);
}
}
// Read the new file, then compare the sequences
IList <ISequence> seqsNew = null;
using (GffParser newParser = new GffParser(Constants.GffTempFileName))
{
seqsNew = newParser.Parse().ToList();
}
Assert.IsNotNull(seqsNew);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: New Sequence is '{0}'.",
seqsNew[0].ToString()));
bool val = ValidateFeatures(seqsNew[0], nodeName);
Assert.IsTrue(val);
ApplicationLog.WriteLine(
"GFF Formatter BVT : All the features validated successfully.");
Console.WriteLine(
"GFF Formatter BVT : All the features validated successfully.");
// Now compare the sequences.
int countNew = seqsNew.Count();
int expectedCount = 1;
Assert.AreEqual(expectedCount, countNew);
ApplicationLog.WriteLine("The Number of sequences are matching.");
Assert.AreEqual(originalSequence.ID, seqsNew[0].ID);
byte[] TempSeqData = new byte[originalSequence.Count];
for (int i = 0; i < originalSequence.Count; i++)
{
TempSeqData[i] = originalSequence[i];
}
string orgSeq = ASCIIEncoding.ASCII.GetString(TempSeqData);
ISequence newSeq = seqsNew.FirstOrDefault();
byte[] TempSeqData1 = new byte[newSeq.Count];
for (int i = 0; i < newSeq.Count; i++)
{
TempSeqData1[i] = newSeq[i];
}
string newSeqString = ASCIIEncoding.ASCII.GetString(TempSeqData1);
Assert.AreEqual(orgSeq, newSeqString);
Console.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: The Gff sequences '{0}' are matching with Format() method and is as expected.",
seqsNew[0].ToString()));
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: The Gff sequences '{0}' are matching with Format() method.",
seqsNew[0].ToString()));
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
if (File.Exists(Constants.GffTempFileName))
{
File.Delete(Constants.GffTempFileName);
}
ApplicationLog.WriteLine("Deleted the temp file created.");
}
public void GffFormatterValidateStreams()
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(Constants.SimpleGffNodeName,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePath));
IList <ISequence> seqs = null;
Sequence originalSequence = null;
GffParser parserObj = new GffParser();
{
seqs = parserObj.Parse(filePath).ToList();
originalSequence = (Sequence)seqs[0];
}
// Use the formatter to write the original sequences to a temp file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: Creating the Temp file '{0}'.",
Constants.GffTempFileName));
using (var writer = File.Create(Constants.GffTempFileName))
{
GffFormatter formatter = new GffFormatter()
{
ShouldWriteSequenceData = true
};
formatter.Format(writer, originalSequence);
}
// Read the new file, then compare the sequences
IList <ISequence> seqsNew = null;
GffParser newParser = new GffParser();
seqsNew = newParser.Parse(Constants.GffTempFileName).ToList();
Assert.IsNotNull(seqsNew);
ApplicationLog.WriteLine(string.Format("Gff Formatter BVT: New Sequence is '{0}'.", seqsNew[0]));
bool val = ValidateFeatures(seqsNew[0], Constants.SimpleGffNodeName);
Assert.IsTrue(val);
ApplicationLog.WriteLine(
"GFF Formatter BVT : All the features validated successfully.");
// Now compare the sequences.
int countNew = seqsNew.Count();
int expectedCount = 1;
Assert.AreEqual(expectedCount, countNew);
ApplicationLog.WriteLine("The Number of sequences are matching.");
Assert.AreEqual(originalSequence.ID, seqsNew[0].ID);
ISequence newSeq = seqsNew.FirstOrDefault();
Assert.AreEqual(new string(originalSequence.Select(x => (char)x).ToArray()),
new string(newSeq.Select(x => (char)x).ToArray()));
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Gff Formatter BVT: The Gff sequences '{0}' are matching with Write() method.",
seqsNew[0].ToString()));
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
if (File.Exists(Constants.GffTempFileName))
{
File.Delete(Constants.GffTempFileName);
}
ApplicationLog.WriteLine("Deleted the temp file created.");
}
/// <summary>
/// Validates the Format() method in Gff Formatter based on the parameters.
/// </summary>
/// <param name="nodeName">Xml Node name to be read.</param>
/// <param name="isFilePath">Is file path passed as parameter?</param>
/// <param name="isSequenceList">Is sequence list passed as parameter?</param>
static void ValidateFormatGeneralTestCases(string nodeName,
bool isFilePath, bool isSequenceList)
{
// Gets the expected sequence from the Xml
string filePath = Utility._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePath));
IList <ISequence> seqs = null;
GffParser parserObj = new GffParser();
seqs = parserObj.Parse(filePath);
Sequence originalSequence = (Sequence)seqs[0];
// Use the formatter to write the original sequences to a temp file
ApplicationLog.WriteLine(string.Format(null,
"Gff Formatter BVT: Creating the Temp file '{0}'.",
Constants.GffTempFileName));
GffFormatter formatter = new GffFormatter();
formatter.ShouldWriteSequenceData = true;
if (isFilePath)
{
if (isSequenceList)
{
formatter.Format(seqs, Constants.GffTempFileName);
}
else
{
formatter.Format(originalSequence,
Constants.GffTempFileName);
}
}
else
{
if (isSequenceList)
{
using (TextWriter writer =
new StreamWriter(Constants.GffTempFileName))
{
formatter.Format(seqs, writer);
}
}
else
{
using (TextWriter writer =
new StreamWriter(Constants.GffTempFileName))
{
formatter.Format(originalSequence, writer);
}
}
}
// Read the new file, then compare the sequences
IList <ISequence> seqsNew = null;
GffParser newParser = new GffParser();
seqsNew = newParser.Parse(Constants.GffTempFileName);
Assert.IsNotNull(seqsNew);
ApplicationLog.WriteLine(string.Format(null,
"Gff Formatter BVT: New Sequence is '{0}'.",
seqsNew[0].ToString()));
bool val = ValidateFeatures(seqsNew[0], nodeName);
Assert.IsTrue(val);
ApplicationLog.WriteLine(
"GFF Formatter BVT : All the features validated successfully.");
Console.WriteLine(
"GFF Formatter BVT : All the features validated successfully.");
// Now compare the sequences.
int countNew = seqsNew.Count();
int expectedCount = 1;
Assert.AreEqual(expectedCount, countNew);
ApplicationLog.WriteLine("The Number of sequences are matching.");
Assert.AreEqual(originalSequence.ID, seqsNew[0].ID);
string orgSeq = originalSequence.ToString();
string newSeq = seqsNew[0].ToString();
Assert.AreEqual(orgSeq, newSeq);
Console.WriteLine(string.Format(null,
"Gff Formatter BVT: The Gff sequences '{0}' are matching with Format() method and is as expected.",
seqsNew[0].ToString()));
ApplicationLog.WriteLine(string.Format(null,
"Gff Formatter BVT: The Gff sequences '{0}' are matching with Format() method.",
seqsNew[0].ToString()));
// Passed all the tests, delete the tmp file. If we failed an Assert,
// the tmp file will still be there in case we need it for debugging.
if (File.Exists(Constants.GffTempFileName))
{
File.Delete(Constants.GffTempFileName);
}
ApplicationLog.WriteLine("Deleted the temp file created.");
}
/// <summary>
/// General method to invalidate Argument Null exceptions generated from different methods.
/// </summary>
/// <param name="nodeName">xml node name.</param>
/// <param name="method">Gff Parse method parameters</param>
void InvalidateGffWriteMethod(ArgumentNullExceptions method)
{
ISequence sequence = null;
List <ISequence> collection = new List <ISequence>();
string sequenceData = null;
GffFormatter gffFormatter = null;
try
{
switch (method)
{
case ArgumentNullExceptions.writeWithEmptyFile:
sequenceData = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleGffDnaNodeName, Constants.ExpectedSequenceNode);
gffFormatter = new GffFormatter();
{
gffFormatter.Format(new Sequence(DnaAlphabet.Instance, sequenceData));
}
break;
case ArgumentNullExceptions.writeWithEmptySequence:
gffFormatter = new GffFormatter();
{
gffFormatter.Format(sequence);
}
break;
case ArgumentNullExceptions.FormatString:
gffFormatter = new GffFormatter();
{
gffFormatter.FormatString(sequence);
}
break;
case ArgumentNullExceptions.writeCollectionWithEmptyFile:
sequenceData = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleGffDnaNodeName, Constants.ExpectedSequenceNode);
collection.Add(new Sequence(DnaAlphabet.Instance, sequenceData));
gffFormatter = new GffFormatter();
{
gffFormatter.Format(collection);
}
break;
case ArgumentNullExceptions.writeCollectionWithEmptySequence:
gffFormatter = new GffFormatter();
{
gffFormatter.Format(collection);
}
break;
default:
break;
}
Assert.Fail();
}
catch (ArgumentNullException)
{
ApplicationLog.WriteLine("GFF P2 : Exception is validated successfully.");
}
catch (Exception)
{
ApplicationLog.WriteLine("GFF P2 : Exception is validated successfully.");
}
}
