public void XsvSparseBvtParserProperties()
{
XsvContigParser xsvParser = new XsvContigParser(Alphabets.DNA, ',', '#');
Assert.AreEqual(Constants.XsvSparseDescription, xsvParser.Description);
Assert.AreEqual(Constants.XsvSparseFileTypes, xsvParser.SupportedFileTypes);
Assert.AreEqual(Constants.XsvSparseName, xsvParser.Name);
ApplicationLog.WriteLine
("Successfully validated all the properties of XsvSparse Parser class.");
}
/// <summary>
/// Parse out a Contig from the given file.
/// </summary>
/// <param name="parser">Parser</param>
/// <param name="filename">Filename</param>
/// <returns>Contig</returns>
public static Contig ParseContig(this XsvContigParser parser, string filename)
{
if (parser == null)
{
throw new ArgumentNullException("parser");
}
if (string.IsNullOrWhiteSpace(filename))
{
throw new ArgumentNullException("filename");
}
using (var fs = File.OpenRead(filename))
{
return(parser.ParseContig(fs));
}
}
public void XsvSparseParseContig()
{
// Gets the expected file from the Xml
string filePathObj = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleXsvSparseNodeName,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePathObj));
// Logs information to the log file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"XsvSparse Formatter BVT: File Exists in the Path '{0}'.",
filePathObj));
XsvContigParser parserObj = new XsvContigParser(Alphabets.DNA, ',', '#');
parserObj.Parse(filePathObj);
Contig contig = parserObj.ParseContig(filePathObj);
// Validate parsed temp file with original Xsv file.
Assert.AreEqual(26048682, contig.Length);
Assert.AreEqual(26048682, contig.Consensus.Count);
Assert.AreEqual("Chr22+Chr22+Chr22+Chr22", contig.Consensus.ID);
Assert.AreEqual(56, contig.Sequences.Count);
// Log to GUI.
ApplicationLog.WriteLine("Successfully validated the ParseConting() method with Xsv file");
}
/// <summary>
/// XsvSparse formatter generic method called by all the test cases
/// to validate the test case based on the parameters passed.
/// </summary>
/// <param name="nodename">Xml node Name.</param>
/// <param name="additionalParam">Additional parameter
/// based on which the validation of test case is done.</param>
void XsvSparseFormatterGeneralTestCases(string nodename,
AdditionalParameters additionalParam)
{
// Gets the expected sequence from the Xml
string filePathObj = this.utilityObj.xmlUtil.GetTextValue(nodename,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePathObj));
// Logs information to the log file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"XsvSparse Formatter BVT: File Exists in the Path '{0}'.",
filePathObj));
IEnumerable<ISequence> seqList = null;
SparseSequence sparseSeq = null;
XsvContigParser parserObj = new XsvContigParser(Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix);
seqList = parserObj.Parse(filePathObj);
sparseSeq = (SparseSequence)seqList.ElementAt(0);
IReadOnlyList<IndexedItem<byte>> sparseSeqItems = sparseSeq.GetKnownSequenceItems();
string tempFile = Path.GetTempFileName();
XsvSparseFormatter formatterObj = new XsvSparseFormatter(Constants.CharSeperator, Constants.SequenceIDPrefix);
switch (additionalParam)
{
case AdditionalParameters.FormatFilePath:
formatterObj.Format(sparseSeq, tempFile);
break;
default:
break;
case AdditionalParameters.ForamtListWithFilePath:
formatterObj.Format(seqList.ToList(), tempFile);
break;
}
XsvContigParser newParserObj = new XsvContigParser(Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix);
// Parse a formatted Xsv file and validate.
seqList = newParserObj.Parse(filePathObj);
SparseSequence expectedSeq = (SparseSequence)seqList.ElementAt(0);
IReadOnlyList<IndexedItem<byte>> expectedSparseSeqItems = expectedSeq.GetKnownSequenceItems();
for (int i = 0; i < sparseSeqItems.Count; i++)
{
IndexedItem<byte> seqItem = sparseSeqItems[i];
IndexedItem<byte> expectedSeqItem = expectedSparseSeqItems[i];
Assert.AreEqual(seqItem.Index, expectedSeqItem.Index);
}
ApplicationLog.WriteLine("Successfully validated the format Xsv file");
}
/// <summary>
/// XsvSparse parser generic method called by all the test cases
/// to validate the test case based on the parameters passed.
/// </summary>
/// <param name="nodename">Xml node Name.</param>
/// based on which the validation of test case is done.</param>
void XsvSparseParserGeneralTestCases(string nodename)
{
// Gets the expected file from the Xml
string filePathObj = this.utilityObj.xmlUtil.GetTextValue(nodename,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePathObj));
// Logs information to the log file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"XsvSparse Parser BVT: File Exists in the Path '{0}'.",
filePathObj));
IEnumerable<ISequence> seqList = null;
SparseSequence sparseSeq = null;
XsvContigParser parserObj = new XsvContigParser(Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix);
string expectedSeqIds = this.utilityObj.xmlUtil.GetTextValue(nodename,
Constants.SequenceIdNode);
seqList = parserObj.Parse(filePathObj);
sparseSeq = (SparseSequence)seqList.ElementAt(0);
if (null == sparseSeq)
{
string expCount = this.utilityObj.xmlUtil.GetTextValue(nodename,
Constants.SequenceCountNode);
Assert.IsNotNull(seqList);
Assert.AreEqual(expCount, seqList.Count());
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"XsvSparse Parser BVT: Number of Sequences found are '{0}'.",
expCount));
string[] expectedSeqIdArray = expectedSeqIds.Split(',');
List<ISequence> sparseSeqList = seqList.ToList();
for (int i = 0; i < expectedSeqIdArray.Length; i++)
{
Assert.AreEqual(expectedSeqIdArray[i], sparseSeqList[i].ID);
}
}
else
{
string[] idArray = expectedSeqIds.Split(',');
Assert.AreEqual(sparseSeq.ID, idArray[0]);
}
ApplicationLog.WriteLine(
"XsvSparse Parser BVT: The XsvSparse sequence is validated successfully with Parse() method.");
Assert.IsNotNull(sparseSeq.Alphabet);
Assert.AreEqual(sparseSeq.Alphabet.Name.ToLower(CultureInfo.InvariantCulture),
this.utilityObj.xmlUtil.GetTextValue(nodename,
Constants.AlphabetNameNode).ToLower(CultureInfo.InvariantCulture));
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"XsvSparse Parser BVT: The Sequence Alphabet is '{0}' and is as expected.",
sparseSeq.Alphabet.Name));
}
public void XsvSparseContigFormatterWrite()
{
// Gets the expected sequence from the Xml
string filePathObj = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleXsvSparseNodeName,
Constants.FilePathNode);
Assert.IsTrue(File.Exists(filePathObj));
// Logs information to the log file
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Xsv Contig Formatter BVT: File Exists in the Path '{0}'.",
filePathObj));
Contig expectedContig;
XsvContigParser parserObj = new XsvContigParser(Alphabets.DNA, ',', '#');
Contig contig = parserObj.ParseContig(filePathObj);
string seqId = contig.Sequences.Aggregate(string.Empty, (current, seq) => current + (seq.Sequence.ID + ","));
// Write Xsv file.
XsvContigFormatter formatObj = new XsvContigFormatter(',', '#');
formatObj.Format(contig, Constants.XsvTempFileName);
XsvContigParser parserObjNew = new XsvContigParser(Alphabets.DNA, ',', '#');
expectedContig = parserObjNew.ParseContig(Constants.XsvTempFileName);
string expectedseqId = expectedContig.Sequences.Aggregate(string.Empty, (current, seq) => current + (seq.Sequence.ID + ","));
// Validate parsed temp file with original Xsv file.
Assert.AreEqual(contig.Length, expectedContig.Length);
Assert.AreEqual(contig.Consensus.Count, expectedContig.Consensus.Count);
Assert.AreEqual(contig.Consensus.ID, expectedContig.Consensus.ID);
Assert.AreEqual(contig.Sequences.Count, expectedContig.Sequences.Count);
Assert.AreEqual(seqId.Length, expectedseqId.Length);
Assert.AreEqual(seqId, expectedseqId);
File.Delete(Constants.XsvTempFileName);
ApplicationLog.WriteLine("Successfully validated the Write Xsv file");
}
public void XsvContigFormatter()
{
// Gets the expected sequence from the Xml
string filePathObj = Directory.GetCurrentDirectory() + XsvFilename;
string xsvTempFileName = Path.GetTempFileName();
Assert.IsTrue(File.Exists(filePathObj));
// Read the contigs
Contig contig = new XsvContigParser(Alphabets.DNA, ',', '#')
.ParseContig(filePathObj);
string seqId = contig.Sequences.Aggregate(string.Empty, (current, seq) => current + (seq.Sequence.ID + ","));
// Format Xsv file.
new XsvContigFormatter(',', '#')
.Format(contig, xsvTempFileName);
Contig expectedContig = new XsvContigParser(Alphabets.DNA, ',', '#')
.ParseContig(xsvTempFileName);
string expectedseqId = expectedContig.Sequences.Aggregate(string.Empty, (current, seq) => current + (seq.Sequence.ID + ","));
// Validate parsed temp file with original Xsv file.
Assert.AreEqual(contig.Length, expectedContig.Length);
Assert.AreEqual(contig.Consensus.Count, expectedContig.Consensus.Count);
Assert.AreEqual(contig.Consensus.ID, expectedContig.Consensus.ID);
Assert.AreEqual(contig.Sequences.Count, expectedContig.Sequences.Count);
Assert.AreEqual(seqId.Length, expectedseqId.Length);
Assert.AreEqual(seqId, expectedseqId);
}
/// <summary>
/// XsvSparse formatter generic method called by all the test cases
/// to validate the test case based on the parameters passed.
/// </summary>
/// <param name="switchParam">Additional parameter
/// based on which the validation of test case is done.</param>
private void XsvSparseFormatterGeneralTestCases(string switchParam)
{
// Gets the expected sequence from the Xml
string filePathObj = Directory.GetCurrentDirectory() + XsvFilename;
Assert.IsTrue(File.Exists(filePathObj));
XsvContigParser parserObj = new XsvContigParser(Alphabets.DNA, ',', '#');
IEnumerable<ISequence> seqList = parserObj.Parse(filePathObj);
SparseSequence sparseSeq = (SparseSequence) seqList.FirstOrDefault();
var sparseSeqItems = sparseSeq.GetKnownSequenceItems();
string xsvTempFileName = Path.GetTempFileName();
XsvSparseFormatter formatterObj = new XsvSparseFormatter(',', '#');
using (formatterObj.Open(xsvTempFileName))
{
switch (switchParam)
{
case "FormatFilePath":
formatterObj.Format(sparseSeq);
break;
case "ForamtListWithFilePath":
formatterObj.Format(sparseSeq);
break;
}
}
// Parse a formatted Xsv file and validate.
var parserObj1 = new XsvContigParser(Alphabets.DNA, ',', '#');
using (parserObj1.Open(xsvTempFileName))
{
seqList = parserObj1.Parse();
SparseSequence expectedSeq = (SparseSequence)seqList.FirstOrDefault();
var expectedSparseSeqItems = expectedSeq.GetKnownSequenceItems();
Assert.AreEqual(sparseSeqItems.Count, expectedSparseSeqItems.Count);
for (int i = 0; i < sparseSeqItems.Count; i++)
{
Assert.AreEqual(sparseSeqItems.ElementAt(i).Index, expectedSparseSeqItems.ElementAt(i).Index);
Assert.AreEqual(sparseSeqItems.ElementAt(i).Item, expectedSparseSeqItems.ElementAt(i).Item);
}
}
// Delete the temporary file.
if (File.Exists(xsvTempFileName))
File.Delete(xsvTempFileName);
}
/// <summary>
/// XsvSparse parser generic method called by all the test cases
/// to validate the test case based on the parameters passed.
/// </summary>
private void XsvSparseParserGeneralTestCases()
{
// Gets the expected sequence from the Xml
string filePathObj = Directory.GetCurrentDirectory() + XsvFilename;
Assert.IsTrue(File.Exists(filePathObj));
XsvContigParser parserObj = new XsvContigParser(Alphabets.DNA, ',', '#');
string expectedSeqIds = "Chr22+Chr22+Chr22+Chr22,m;Chr22;16,m;Chr22;17,m;Chr22;29,m;Chr22;32,m;Chr22;39,m;Chr22;54,m;Chr22;72,m;Chr22;82,m;Chr22;85,m;Chr22;96,m;Chr22;99,m;Chr22;118,m;Chr22;119,m;Chr22;129,m;Chr22;136,m;Chr22;146,m;Chr22;153,m;Chr22;161,m;Chr22;162,m;Chr22;174,m;Chr22;183,m;Chr22;209,m;Chr22;210,m;Chr22;224,m;Chr22;241,m;Chr22;243,m;Chr22;253,m;Chr22;267,m;Chr22;309,m;Chr22;310,m;Chr22;313,m;Chr22;331,m;Chr22;333,m;Chr22;338,m;Chr22;348,m;Chr22;352,m;Chr22;355,m;Chr22;357,m;Chr22;368,m;Chr22;370,m;Chr22;380,m;Chr22;382,m;Chr22;402,m;Chr22;418,m;Chr22;419,m;Chr22;429,m;Chr22;432,m;Chr22;450,m;Chr22;462,m;Chr22;482,m;Chr22;484,m;Chr22;485,m;Chr22;494,m;Chr22;508,m;Chr22;509,m;Chr22;512,";
IEnumerable<ISequence> seqList = parserObj.Parse(filePathObj);
SparseSequence sparseSeq = (SparseSequence) seqList.FirstOrDefault();
if (null == sparseSeq)
{
string expCount = "57";
Assert.IsNotNull(seqList);
Assert.AreEqual(expCount, seqList.ToList().Count);
StringBuilder actualId = new StringBuilder();
foreach (ISequence seq in seqList)
{
SparseSequence sps = (SparseSequence)seq;
actualId.Append(sps.ID);
actualId.Append(",");
}
Assert.AreEqual(expectedSeqIds, actualId.ToString());
}
else
{
string[] idArray = expectedSeqIds.Split(',');
Assert.AreEqual(sparseSeq.ID, idArray[0]);
}
string XsvTempFileName = Path.GetTempFileName();
XsvSparseFormatter formatter = new XsvSparseFormatter(',', '#');
using (formatter.Open(XsvTempFileName))
{
formatter.Format(seqList.ToList());
}
string expectedOutput = string.Empty;
using (StreamReader readerSource = new StreamReader(filePathObj))
{
expectedOutput = readerSource.ReadToEnd();
}
string actualOutput = string.Empty;
using (StreamReader readerDest = new StreamReader(XsvTempFileName))
{
actualOutput = readerDest.ReadToEnd();
}
Assert.AreEqual(expectedOutput.Replace("\r\n", System.Environment.NewLine), actualOutput);
Assert.IsNotNull(sparseSeq.Alphabet);
// Delete the temporary file.
if (File.Exists(XsvTempFileName))
File.Delete(XsvTempFileName);
}