public void XsvContigFormatter() { // Gets the expected sequence from the Xml string filePathObj = XsvFilename.TestDir(); 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 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> /// <param name="additionalParam">Additional parameter /// based on which the validation of test case is done.</param> void XsvSparseParserGeneralTestCases(string nodename) { // Gets the expected file from the Xml string filePathObj = 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(filePathObj, Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix); string expectedSeqIds = utilityObj.xmlUtil.GetTextValue(nodename, Constants.SequenceIdNode); seqList = parserObj.Parse(); sparseSeq = (SparseSequence)seqList.ElementAt(0); if (null == sparseSeq) { string expCount = 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), 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 XsvSparseParseContig() { // Gets the expected file from the Xml string filePathObj = 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)); using (XsvContigParser parserObj = new XsvContigParser(filePathObj, Alphabets.DNA, ',', '#')) { parserObj.Parse(); Contig contig = parserObj.ParseContig(); // 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. Console.WriteLine("Successfully validated the ParseConting() method with Xsv file"); ApplicationLog.WriteLine("Successfully validated the ParseConting() method with Xsv file"); }
public void XsvSparseContigFormatterWrite() { // Gets the expected sequence from the Xml string filePathObj = 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 contig, expectedContig; using (XsvContigParser parserObj = new XsvContigParser(filePathObj, Alphabets.DNA, ',', '#')) { contig = parserObj.ParseContig(); } string seqId = string.Empty; foreach (Contig.AssembledSequence seq in contig.Sequences) { seqId += seq.Sequence.ID + ","; } // Write Xsv file. using (XsvContigFormatter formatObj = new XsvContigFormatter(Constants.XsvTempFileName, ',', '#')) { formatObj.Write(contig); } using (XsvContigParser parserObjNew = new XsvContigParser(Constants.XsvTempFileName, Alphabets.DNA, ',', '#')) { expectedContig = parserObjNew.ParseContig(); } string expectedseqId = string.Empty; foreach (Contig.AssembledSequence seq in expectedContig.Sequences) { expectedseqId += 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); // Log to VSTest GUI. Console.WriteLine("Successfully validated the Write Xsv file"); ApplicationLog.WriteLine("Successfully validated the Write 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).TestDir(); 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 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 = XsvFilename.TestDir(); 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); } }
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."); }
public void XsvSparseBvtParserProperties() { // Gets the expected file from the Xml string filePathObj = utilityObj.xmlUtil.GetTextValue(Constants.SimpleXsvSparseNodeName, Constants.FilePathNode); XsvContigParser xsvParser = new XsvContigParser(filePathObj, 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."); }
public void XsvContigFormatter() { // Gets the expected sequence from the Xml string filePathObj = Directory.GetCurrentDirectory() + XsvFilename; string XsvTempFileName = Path.GetTempFileName(); Assert.IsTrue(File.Exists(filePathObj)); XsvContigParser parserObj = new XsvContigParser(filePathObj, Alphabets.DNA, ',', '#'); Contig contig, expectedContig; contig = parserObj.ParseContig(); string seqId = string.Empty; foreach (Contig.AssembledSequence seq in contig.Sequences) { seqId += seq.Sequence.ID + ","; } // Format Xsv file. XsvContigFormatter formatObj = new XsvContigFormatter(XsvTempFileName, ',', '#'); formatObj.Write(contig); formatObj.Close(); formatObj.Dispose(); XsvContigParser parserObj1 = new XsvContigParser(XsvTempFileName, Alphabets.DNA, ',', '#'); expectedContig = parserObj1.ParseContig(); string expectedseqId = string.Empty; foreach (Contig.AssembledSequence seq in expectedContig.Sequences) { expectedseqId += 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); }
public void XsvSparseContigFormatterWrite() { // Gets the expected sequence from the Xml string filePathObj = this.utilityObj.xmlUtil.GetTextValue( Constants.SimpleXsvSparseNodeName, Constants.FilePathNode).TestDir(); 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 XsvSparseBvtFormatterFormatString() { // Gets the expected sequence from the Xml string filePathObj = Utility._xmlUtil.GetTextValue(Constants.SimpleXsvSparseNodeName, Constants.FilePathNode); string expectedString = Utility._xmlUtil.GetTextValue(Constants.SimpleXsvSparseNodeName, Constants.expectedString); Assert.IsTrue(File.Exists(filePathObj)); // Logs information to the log file ApplicationLog.WriteLine(string.Format(null, "XsvSparse Formatter BVT: File Exists in the Path '{0}'.", filePathObj)); IList <ISequence> seqList = null; SparseSequence sparseSeq = null; XsvContigParser parserObj = new XsvContigParser(Encodings.IupacNA, Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix); seqList = parserObj.Parse(filePathObj); sparseSeq = (SparseSequence)seqList[0]; XsvSparseFormatter formatterObj = new XsvSparseFormatter(Constants.CharSeperator, Constants.SequenceIDPrefix); string formattedString = formatterObj.FormatString(sparseSeq); formattedString = formattedString.Replace("\r", "").Replace("\n", ""); Assert.AreEqual(expectedString, formattedString); // Log to Nunit GUI. Console.WriteLine("Successfully validated the formatString Xsv file"); ApplicationLog.WriteLine("Successfully validated the formatString Xsv file"); }
/// <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 = XsvFilename.TestDir(); 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(Utility.CleanupWhiteSpace(expectedOutput), Utility.CleanupWhiteSpace(actualOutput)); Assert.IsNotNull(sparseSeq.Alphabet); // Delete the temporary file. if (File.Exists(XsvTempFileName)) { File.Delete(XsvTempFileName); } }
/// <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> static void XsvSparseFormatterGeneralTestCases(string nodename, AdditionalParameters additionalParam) { // Gets the expected sequence from the Xml string filePathObj = Utility._xmlUtil.GetTextValue(nodename, Constants.FilePathNode); Assert.IsTrue(File.Exists(filePathObj)); // Logs information to the log file ApplicationLog.WriteLine(string.Format(null, "XsvSparse Formatter BVT: File Exists in the Path '{0}'.", filePathObj)); IList <ISequence> seqList = null; SparseSequence sparseSeq = null; XsvContigParser parserObj = new XsvContigParser(Encodings.IupacNA, Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix); seqList = parserObj.Parse(filePathObj); sparseSeq = (SparseSequence)seqList[0]; IList <IndexedItem <ISequenceItem> > sparseSeqItems = sparseSeq.GetKnownSequenceItems(); XsvSparseFormatter formatterObj = new XsvSparseFormatter(Constants.CharSeperator, Constants.SequenceIDPrefix); switch (additionalParam) { case AdditionalParameters.FormatFilePath: formatterObj.Format(sparseSeq, Constants.XsvTempFileName); break; default: break; case AdditionalParameters.ForamtListWithFilePath: formatterObj.Format(seqList, Constants.XsvTempFileName); break; case AdditionalParameters.FormatTextWriter: using (TextWriter writer = new StreamWriter(Constants.XsvTempFileName)) { formatterObj.Format(sparseSeq, writer); } break; case AdditionalParameters.FormatTextWriterWithOffset: using (TextWriter writer = new StreamWriter(Constants.XsvTempFileName)) { formatterObj.Format(sparseSeq, 0, writer); } break; case AdditionalParameters.FormatListTextWriter: using (TextWriter writer = new StreamWriter(Constants.XsvTempFileName)) { formatterObj.Format(seqList, writer); } break; } // Parse a formatted Xsv file and validate. SparseSequence expectedSeq; seqList = parserObj.Parse(Constants.XsvTempFileName); expectedSeq = (SparseSequence)seqList[0]; IList <IndexedItem <ISequenceItem> > expectedSparseSeqItems = expectedSeq.GetKnownSequenceItems(); for (int i = 0; i < sparseSeqItems.Count; i++) { IndexedItem <ISequenceItem> seqItem = sparseSeqItems[i]; IndexedItem <ISequenceItem> expectedSeqItem = expectedSparseSeqItems[i]; Assert.AreEqual(seqItem.Index, expectedSeqItem.Index); } // Log to Nunit GUI. Console.WriteLine("Successfully validated the format Xsv file"); ApplicationLog.WriteLine("Successfully validated the format Xsv file"); // Delete the temporary file. if (File.Exists(Constants.XsvTempFileName)) { File.Delete(Constants.XsvTempFileName); } }
/// <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> /// <param name="additionalParam">Additional parameter /// based on which the validation of test case is done.</param> static void XsvSparseParserGeneralTestCases(string nodename, AdditionalParameters additionalParam) { // Gets the expected sequence from the Xml string filePathObj = Utility._xmlUtil.GetTextValue(nodename, Constants.FilePathNode); Assert.IsTrue(File.Exists(filePathObj)); // Logs information to the log file ApplicationLog.WriteLine(string.Format(null, "XsvSparse Parser BVT: File Exists in the Path '{0}'.", filePathObj)); IList <ISequence> seqList = null; SparseSequence sparseSeq = null; XsvContigParser parserObj = new XsvContigParser(Encodings.IupacNA, Alphabets.DNA, Constants.CharSeperator, Constants.SequenceIDPrefix); string expectedSeqIds = Utility._xmlUtil.GetTextValue(nodename, Constants.SequenceIdNode); switch (additionalParam) { case AdditionalParameters.ParseTextReader: seqList = parserObj.Parse(new StreamReader(filePathObj)); sparseSeq = (SparseSequence)seqList[0]; break; case AdditionalParameters.ParseOneTextReader: sparseSeq = (SparseSequence)parserObj.ParseOne(new StreamReader(filePathObj)); break; case AdditionalParameters.ParseOneFilePath: sparseSeq = (SparseSequence)parserObj.ParseOne(filePathObj); break; case AdditionalParameters.ParseFilePath: seqList = parserObj.Parse(filePathObj); sparseSeq = (SparseSequence)seqList[0]; break; case AdditionalParameters.ParseTextReaderReadOnly: seqList = parserObj.Parse(new StreamReader(filePathObj), false); sparseSeq = (SparseSequence)seqList[0]; break; case AdditionalParameters.ParseOneTextReaderReadOnly: sparseSeq = (SparseSequence)parserObj.ParseOne(new StreamReader(filePathObj), false); break; case AdditionalParameters.ParseOneFilePathReadOnly: sparseSeq = (SparseSequence)parserObj.ParseOne(filePathObj, false); break; default: seqList = parserObj.Parse(filePathObj, false); sparseSeq = (SparseSequence)seqList[0]; break; } if (null == sparseSeq) { string expCount = Utility._xmlUtil.GetTextValue(nodename, Constants.SequenceCountNode); Assert.IsNotNull(seqList); Assert.AreEqual(expCount, seqList.Count); ApplicationLog.WriteLine(string.Format(null, "XsvSparse Parser BVT: Number of Sequences found are '{0}'.", expCount)); 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.DisplayID, idArray[0]); } ApplicationLog.WriteLine( "XsvSparse Parser BVT: The XsvSparse sequence is validated successfully with Parse() method."); // Logs to the NUnit GUI (Console.Out) window Console.WriteLine( "XsvSparse Parser BVT: The XsvSparse sequence is validated successfully with Parse() method."); Assert.IsNotNull(sparseSeq.Alphabet); Assert.AreEqual(sparseSeq.Alphabet.Name.ToLower(CultureInfo.CurrentCulture), Utility._xmlUtil.GetTextValue(nodename, Constants.AlphabetNameNode).ToLower(CultureInfo.CurrentCulture)); ApplicationLog.WriteLine(string.Format(null, "XsvSparse Parser BVT: The Sequence Alphabet is '{0}' and is as expected.", sparseSeq.Alphabet.Name)); }
public void XsvSparseContigFormatterFormat() { // Gets the expected sequence from the Xml string filePathObj = Utility._xmlUtil.GetTextValue( Constants.SimpleXsvSparseNodeName, Constants.FilePathNode); Assert.IsTrue(File.Exists(filePathObj)); // Logs information to the log file ApplicationLog.WriteLine(string.Format(null, "XsvSparse Formatter BVT: File Exists in the Path '{0}'.", filePathObj)); IEncoding encode = Encodings.IupacNA; XsvContigParser parserObj = new XsvContigParser(encode, Alphabets.DNA, ',', '#'); Contig contig, expectedContig; // Parse a file. using (TextReader tr = new StreamReader(File.OpenRead(filePathObj))) { contig = parserObj.ParseContig(tr, false); } string seqId = string.Empty; foreach (Contig.AssembledSequence seq in contig.Sequences) { seqId += seq.Sequence.ID + ","; } // Format Xsv file. XsvContigFormatter formatObj = new XsvContigFormatter(',', '#'); using (TextWriter tw = new StreamWriter(File.OpenWrite( Constants.XsvTempFileName))) { formatObj.Format(contig, tw); } // Parse formatted TempFile. using (TextReader tr = new StreamReader( File.OpenRead(Constants.XsvTempFileName))) { expectedContig = parserObj.ParseContig(tr, false); } string expectedseqId = string.Empty; foreach (Contig.AssembledSequence seq in expectedContig.Sequences) { expectedseqId += 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.DisplayID, expectedContig.Consensus.DisplayID); 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); // Log to Nunit GUI. Console.WriteLine("Successfully validated the format Xsv file"); ApplicationLog.WriteLine("Successfully validated the format 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="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)); IEnumerable <ISequence> seqList = null; SparseSequence sparseSeq = null; XsvContigParser parserObj = new XsvContigParser(filePathObj, Alphabets.DNA, ',', '#'); seqList = parserObj.Parse(); sparseSeq = (SparseSequence)seqList.FirstOrDefault(); IList <IndexedItem <byte> > sparseSeqItems = sparseSeq.GetKnownSequenceItems(); string XsvTempFileName = Path.GetTempFileName(); using (XsvSparseFormatter formatterObj = new XsvSparseFormatter(XsvTempFileName, ',', '#')) { switch (switchParam) { case "FormatFilePath": formatterObj.Write(sparseSeq); break; default: break; case "ForamtListWithFilePath": formatterObj.Write(sparseSeq); break; } } // Parse a formatted Xsv file and validate. using (XsvContigParser parserObj1 = new XsvContigParser(XsvTempFileName, Alphabets.DNA, ',', '#')) { SparseSequence expectedSeq; seqList = parserObj1.Parse(); expectedSeq = (SparseSequence)seqList.FirstOrDefault(); IList <IndexedItem <byte> > 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); } }