public void ValidateDnaSparseSequenceProperties() { IAlphabet alphabet = Alphabets.DNA; // Create sparse sequence object int insertPosition = 0; // Create sequence item list IList <byte> sequenceList = new List <byte>(); foreach (byte item in alphabet) { sequenceList.Add(item); } // Store sequence item in sparse sequence object using list of sequence items SparseSequence sparseSequence = new SparseSequence(alphabet, insertPosition, sequenceList); //Validate all properties Assert.AreEqual(alphabet.Count + insertPosition, sparseSequence.Count); Assert.AreEqual(alphabet, sparseSequence.Alphabet); Assert.IsTrue(string.IsNullOrEmpty(sparseSequence.ID)); Assert.IsNotNull(sparseSequence.Metadata); Assert.IsNotNull(sparseSequence.Statistics); Assert.IsNotNull(sparseSequence.GetKnownSequenceItems()); Console.WriteLine( "SparseSequence BVT: Validation of all properties of sparse sequence instance is completed"); ApplicationLog.WriteLine( "SparseSequence BVT: Validation of all properties of sparse sequence instance is completed"); }
public void ValidateSparseSequenceGetKnownSequenceItems() { byte[] byteArrayObj = encodingObj.GetBytes("ACGT"); IEnumerable <byte> seqItems = new List <Byte>() { byteArrayObj[0], byteArrayObj[1], byteArrayObj[2], byteArrayObj[3] }; SparseSequence sparseSeqObj = new SparseSequence(Alphabets.DNA, 0, seqItems); IList <IndexedItem <byte> > revSeqObj = sparseSeqObj.GetKnownSequenceItems(); long i = 0; foreach (IndexedItem <byte> by in revSeqObj) { Assert.AreEqual(i, by.Index); Assert.AreEqual(byteArrayObj[i], by.Item); i++; } Console.WriteLine( "SparseSequenceBVT: Validation of GetKnownSequenceItems() method successfully completed"); ApplicationLog.WriteLine( "SparseSequenceBVT: Validation of GetKnownSequenceItems() method successfully completed"); }
/// <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 TestSparseSequenceGetKnownSequenceItems() { ISequence seq = new Sequence(Alphabets.DNA, "ATGC"); var sparseSeq = new SparseSequence(Alphabets.DNA, 0, seq); IList <IndexedItem <byte> > knownItems = sparseSeq.GetKnownSequenceItems(); Assert.AreEqual(knownItems.Count, 4); Assert.AreEqual(0, knownItems[0].Index); Assert.AreEqual(Alphabets.DNA.A, knownItems[0].Item); Assert.AreEqual(1, knownItems[1].Index); Assert.AreEqual(Alphabets.DNA.T, knownItems[1].Item); Assert.AreEqual(2, knownItems[2].Index); Assert.AreEqual(Alphabets.DNA.G, knownItems[2].Item); Assert.AreEqual(3, knownItems[3].Index); Assert.AreEqual(Alphabets.DNA.C, knownItems[3].Item); }
/// <summary> /// Creates a sparse a sequence and inserts all sequence items of alphabet. /// Validates various properties present in the sparse class. /// </summary> /// <param name="alphabet">alphabet instance.</param> /// <param name="nodeName">xml node.</param> private void ValidateSparseSequenceAllProperties(IAlphabet alphabet, string nodeName) { // Get expected values from xml file. string expectedComplement = Utility._xmlUtil.GetTextValue( nodeName, Constants.Complement); string expectedReverse = Utility._xmlUtil.GetTextValue( nodeName, Constants.Reverse); string expectedReverseComplement = Utility._xmlUtil.GetTextValue( nodeName, Constants.ReverseComplement); // Create sparse sequence object int insertPosition = 0; SparseSequence sparseSequence = CreateSparseSequence(alphabet, insertPosition); sparseSequence.DisplayID = "Display ID"; //Validate all properties Assert.AreEqual(alphabet.Count + insertPosition, sparseSequence.Count); Assert.AreEqual(alphabet, sparseSequence.Alphabet); Assert.AreEqual(expectedComplement, sparseSequence.Complement.ToString()); Assert.AreEqual("Display ID", sparseSequence.DisplayID); Assert.IsNull(sparseSequence.Documentation); Assert.IsEmpty(sparseSequence.ID); Assert.IsTrue(sparseSequence.IsReadOnly); Assert.IsEmpty(sparseSequence.Metadata); Assert.AreEqual(MoleculeType.Invalid, sparseSequence.MoleculeType); Assert.AreEqual(expectedReverse, sparseSequence.Reverse.ToString()); Assert.AreEqual(expectedReverseComplement, sparseSequence.ReverseComplement.ToString()); Assert.IsNotNull(sparseSequence.Statistics); Assert.IsNotNull(sparseSequence.GetKnownSequenceItems()); Console.WriteLine( "SparseSequenceBVT: Validation of all properties of sparse sequence instance is completed"); ApplicationLog.WriteLine( "SparseSequenceBVT: Validation of all properties of sparse sequence instance is completed"); }
public void TestSparseSequence() { SparseSequence tempSeq = null; #region Test constructors by passing invalid parameters. try { tempSeq = new SparseSequence(Alphabets.DNA, 0, Alphabets.RNA.U); Assert.Fail(); } catch (ArgumentException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence(Alphabets.RNA, 0, Alphabets.DNA.T); Assert.Fail(); } catch (ArgumentException) { Assert.IsNull(tempSeq); } try { ISequence seq = new Sequence(Alphabets.RNA, "AUGC"); tempSeq = new SparseSequence(Alphabets.DNA, 0, seq); Assert.Fail(); } catch (ArgumentException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence(Alphabets.DNA, -1, Alphabets.DNA.A); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence(Alphabets.DNA, int.MaxValue, Alphabets.DNA.A); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence(Alphabets.DNA, 0, null as ISequenceItem); Assert.Fail(); } catch (ArgumentNullException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence(Alphabets.DNA, 0, null as ISequence); Assert.Fail(); } catch (ArgumentNullException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence( Alphabets.DNA, -1, new List <ISequenceItem>() { Alphabets.DNA.A, Alphabets.DNA.C }); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.IsNull(tempSeq); } try { tempSeq = new SparseSequence( Alphabets.DNA, int.MaxValue, new List <ISequenceItem>() { Alphabets.DNA.A, Alphabets.DNA.C }); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.IsNull(tempSeq); } #endregion Test constructors by passing invalid parameters. // Test constructor which takes only Alphabet for the IsReadOnly property. SparseSequence sparseSeq = new SparseSequence(Alphabets.DNA); Assert.IsFalse(sparseSeq.IsReadOnly); sparseSeq.Insert(0, 'C'); Assert.AreEqual(sparseSeq.Count, 1); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); sparseSeq = new SparseSequence(Alphabets.DNA, 0, Alphabets.DNA.A); string id = Guid.NewGuid().ToString(string.Empty); sparseSeq.ID = id; sparseSeq.DisplayID = "SparseSeq1"; #region Test parameters Assert.AreSame(Alphabets.DNA, sparseSeq.Alphabet); Assert.IsTrue(sparseSeq.IsReadOnly); Assert.AreSame(sparseSeq.Complement[0], Alphabets.DNA.T); Assert.AreEqual(sparseSeq.Count, 1); Assert.AreEqual(sparseSeq.DisplayID, "SparseSeq1"); Assert.AreEqual(sparseSeq.ID, id); #endregion Test parameters #region Test editing with IsReadOnly set to true. try { sparseSeq.Add(Alphabets.DNA.A); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.Clear(); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.Insert(0, 'C'); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.Insert(0, Alphabets.DNA.A); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.InsertRange(0, "CGA"); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.Remove(Alphabets.DNA.A); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.RemoveAt(0); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.RemoveRange(0, 2); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); } try { sparseSeq.Replace(0, 'C'); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); } try { sparseSeq.Replace(0, Alphabets.DNA.C); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); } try { sparseSeq.ReplaceRange(0, "G"); Assert.Fail(); } catch (InvalidOperationException) { Assert.AreEqual(sparseSeq.Count, 1); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); } #endregion Test editing with IsReadOnly set to true. #region Test not supported members string sequencedata = string.Empty; try { sequencedata = sparseSeq.ToString(); Assert.Fail(); } catch (NotSupportedException) { Assert.IsTrue(string.IsNullOrEmpty(sequencedata)); } #endregion Test not supported members Assert.AreEqual(sparseSeq.IndexOf(Alphabets.DNA.A), 0); Assert.AreSame(sparseSeq.Range(0, 1)[0], Alphabets.DNA.A); Assert.AreSame(sparseSeq.Reverse[0], Alphabets.DNA.A); Assert.AreSame(sparseSeq.ReverseComplement[0], Alphabets.DNA.T); Assert.IsTrue(sparseSeq.Contains(Alphabets.DNA.A)); ISequenceItem[] seqItemArray = new Nucleotide[10]; seqItemArray[0] = Alphabets.DNA.G; sparseSeq.CopyTo(seqItemArray, 1); Assert.AreSame(seqItemArray[0], Alphabets.DNA.G); Assert.AreSame(seqItemArray[1], Alphabets.DNA.A); try { sparseSeq.CopyTo(null, 1); Assert.Fail(); } catch (ArgumentNullException) { } Assert.IsTrue(sparseSeq.IsReadOnly); sparseSeq.IsReadOnly = false; #region Test editing with IsReadOnly set to false. #region Test - void Add(ISequenceItem) sparseSeq.Add(Alphabets.DNA.G); Assert.AreEqual(sparseSeq.Count, 2); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); try { sparseSeq.Add(Alphabets.RNA.U); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 2); } #endregion Test - void Add(ISequenceItem) #region Test - void Clear() sparseSeq.Clear(); Assert.AreEqual(sparseSeq.Count, 0); #endregion Test - void Clear() #region Test - void Insert(int position, char character) sparseSeq.Insert(0, 'C'); Assert.AreEqual(sparseSeq.Count, 1); sparseSeq.Insert(sparseSeq.Count, 'A'); Assert.AreEqual(sparseSeq.Count, 2); try { sparseSeq.Insert(-1, 'A'); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 2); } try { sparseSeq.Insert(sparseSeq.Count + 1, 'A'); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 2); } try { sparseSeq.Insert(0, 'U'); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 2); } #endregion Test - void Insert(int position, char character) #region Test - void Insert(int index, ISequenceItem item) sparseSeq.Insert(0, Alphabets.DNA.G); Assert.AreEqual(sparseSeq.Count, 3); sparseSeq.Insert(sparseSeq.Count, Alphabets.DNA.G); Assert.AreEqual(sparseSeq.Count, 4); try { sparseSeq.Insert(-1, Alphabets.DNA.A); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 4); } try { sparseSeq.Insert(sparseSeq.Count + 1, Alphabets.DNA.A); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 4); } try { sparseSeq.Insert(0, Alphabets.RNA.U); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 4); } #endregion Test - void Insert(int index, ISequenceItem item) #region Test - Count sparseSeq.Clear(); Assert.AreEqual(sparseSeq.Count, 0); sparseSeq.Count = 5; Assert.IsNull(sparseSeq[0]); Assert.IsNull(sparseSeq[1]); Assert.IsNull(sparseSeq[2]); Assert.IsNull(sparseSeq[3]); Assert.IsNull(sparseSeq[4]); sparseSeq[2] = Alphabets.DNA.G; Assert.AreEqual(sparseSeq.Count, 5); Assert.IsNull(sparseSeq[0]); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.G); Assert.IsNull(sparseSeq[3]); Assert.IsNull(sparseSeq[4]); sparseSeq.Insert(2, 'A'); Assert.AreEqual(sparseSeq.Count, 6); Assert.IsNull(sparseSeq[0]); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.A); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.IsNull(sparseSeq[4]); Assert.IsNull(sparseSeq[5]); sparseSeq.Insert(4, Alphabets.DNA.C); Assert.AreEqual(sparseSeq.Count, 7); Assert.IsNull(sparseSeq[0]); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.A); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); Assert.IsNull(sparseSeq[5]); Assert.IsNull(sparseSeq[6]); #endregion Test - Count #region Test - void InsertRange(int position, string sequence) sparseSeq.InsertRange(0, "CGA"); Assert.AreEqual(sparseSeq.Count, 10); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.A); Assert.IsNull(sparseSeq[3]); Assert.IsNull(sparseSeq[4]); Assert.AreSame(sparseSeq[5], Alphabets.DNA.A); Assert.AreSame(sparseSeq[6], Alphabets.DNA.G); Assert.AreSame(sparseSeq[7], Alphabets.DNA.C); Assert.IsNull(sparseSeq[8]); Assert.IsNull(sparseSeq[9]); try { sparseSeq.InsertRange(-1, "CGA"); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 10); } try { sparseSeq.InsertRange(sparseSeq.Count + 1, "CGA"); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 10); } try { sparseSeq.InsertRange(0, string.Empty); Assert.Fail(); } catch (ArgumentNullException) { Assert.AreEqual(sparseSeq.Count, 10); } try { sparseSeq.InsertRange(0, null); Assert.Fail(); } catch (ArgumentNullException) { Assert.AreEqual(sparseSeq.Count, 10); } #endregion Test - void InsertRange(int position, string sequence) #region Test - bool Remove(ISequenceItem item) Assert.IsTrue(sparseSeq.Remove(Alphabets.DNA.A)); Assert.AreEqual(sparseSeq.Count, 9); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.IsNull(sparseSeq[2]); Assert.IsNull(sparseSeq[3]); Assert.AreSame(sparseSeq[4], Alphabets.DNA.A); Assert.AreSame(sparseSeq[5], Alphabets.DNA.G); Assert.AreSame(sparseSeq[6], Alphabets.DNA.C); Assert.IsNull(sparseSeq[7]); Assert.IsNull(sparseSeq[8]); Assert.IsFalse(sparseSeq.Remove(Alphabets.DNA.T)); Assert.IsFalse(sparseSeq.Remove(Alphabets.RNA.U)); Assert.AreEqual(sparseSeq.Count, 9); #endregion Test - bool Remove(ISequenceItem item) #region Test - void RemoveAt(int index) sparseSeq.RemoveAt(2); Assert.AreEqual(sparseSeq.Count, 8); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.IsNull(sparseSeq[2]); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.AreSame(sparseSeq[4], Alphabets.DNA.G); Assert.AreSame(sparseSeq[5], Alphabets.DNA.C); Assert.IsNull(sparseSeq[6]); Assert.IsNull(sparseSeq[7]); try { sparseSeq.RemoveAt(-1); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 8); } try { sparseSeq.RemoveAt(sparseSeq.Count); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 8); } #endregion Test - void RemoveAt(int index) #region Test - void RemoveRange(int position, int length) sparseSeq.RemoveRange(1, 3); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.C); Assert.IsNull(sparseSeq[3]); Assert.IsNull(sparseSeq[4]); try { sparseSeq.RemoveRange(-1, 1); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); } try { sparseSeq.RemoveRange(sparseSeq.Count, 1); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); } try { sparseSeq.RemoveRange(0, -1); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); } try { sparseSeq.RemoveRange(2, 4); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 5); } #endregion Test - void RemoveRange(int position, int length) #region Test - void Replace(int position, char character) sparseSeq.Replace(3, 'A'); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.C); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.IsNull(sparseSeq[4]); sparseSeq.Replace(2, 'T'); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.IsNull(sparseSeq[4]); try { sparseSeq.Replace(-1, 'C'); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.Replace(sparseSeq.Count, 'C'); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.Replace(2, 'U'); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.G); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.IsNull(sparseSeq[4]); } #endregion Test - void Replace(int position, char character) #region Test - void Replace(int position, ISequenceItem item) sparseSeq.Replace(1, null); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.A); Assert.IsNull(sparseSeq[4]); sparseSeq.Replace(3, Alphabets.DNA.T); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); sparseSeq.Replace(1, Alphabets.DNA.C); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); // try replacing null with null. sparseSeq[4] = null; try { sparseSeq.Replace(-1, Alphabets.DNA.A); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.Replace(sparseSeq.Count, Alphabets.DNA.A); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.Replace(2, Alphabets.RNA.U); Assert.Fail(); } catch (ArgumentException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } #endregion Test - void Replace(int position, ISequenceItem item) #region Test - void ReplaceRange(int position, string sequence) try { sparseSeq.ReplaceRange(-1, "GC"); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.ReplaceRange(sparseSeq.Count, "GC"); Assert.Fail(); } catch (ArgumentOutOfRangeException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.ReplaceRange(0, string.Empty); Assert.Fail(); } catch (ArgumentNullException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } try { sparseSeq.ReplaceRange(0, null); Assert.Fail(); } catch (ArgumentNullException) { Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.T); Assert.IsNull(sparseSeq[4]); } sparseSeq.ReplaceRange(3, "GC"); Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.AreSame(sparseSeq[1], Alphabets.DNA.C); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); #endregion Test - void ReplaceRange(int position, string sequence) #region Test - ISequenceItem this[int index] sparseSeq[1] = null; Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); sparseSeq[0] = Alphabets.DNA.A; Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); try { sparseSeq[-1] = Alphabets.DNA.A; Assert.Fail(); } catch (ArgumentOutOfRangeException) { } try { sparseSeq[sparseSeq.Count] = Alphabets.DNA.A; Assert.Fail(); } catch (ArgumentOutOfRangeException) { } Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); #endregion Test - ISequenceItem this[int index] #region Test - IList<IndexedSequenceItem> GetKnownSequenceItems IList <IndexedItem <ISequenceItem> > knownItems = sparseSeq.GetKnownSequenceItems(); Assert.AreEqual(knownItems.Count, 4); Assert.AreEqual(knownItems[0].Index, 0); Assert.AreSame(knownItems[0].Item, Alphabets.DNA.A); Assert.AreEqual(knownItems[1].Index, 2); Assert.AreSame(knownItems[1].Item, Alphabets.DNA.T); Assert.AreEqual(knownItems[2].Index, 3); Assert.AreSame(knownItems[2].Item, Alphabets.DNA.G); Assert.AreEqual(knownItems[3].Index, 4); Assert.AreSame(knownItems[3].Item, Alphabets.DNA.C); #endregion Test - IList<IndexedSequenceItem> GetKnownSequenceItems #region Test - IEnumerator<ISequenceItem> GetEnumerator() int i = 0; foreach (ISequenceItem item in sparseSeq) { Assert.AreSame(sparseSeq[i++], item); } #endregion Test - IEnumerator<ISequenceItem> GetEnumerator() #endregion Test editing with IsReadOnly set to false. #region Test - Constructor by passing a sparse sequence. // Create new sparse sequence from a sparse sequence by adding sequence item from index 1. tempSeq = new SparseSequence(sparseSeq.Alphabet, 1, sparseSeq); Assert.AreEqual(tempSeq.Count, 6); Assert.IsNull(tempSeq[0]); Assert.AreSame(tempSeq[1], Alphabets.DNA.A); Assert.IsNull(tempSeq[2]); Assert.AreSame(tempSeq[3], Alphabets.DNA.T); Assert.AreSame(tempSeq[4], Alphabets.DNA.G); Assert.AreSame(tempSeq[5], Alphabets.DNA.C); #endregion Test - Constructor by passing a sparse sequence. #region Test - Complement ISequence compSeq = sparseSeq.Complement; Assert.AreEqual(compSeq.Count, 5); Assert.AreSame(compSeq[0], Alphabets.DNA.T); Assert.IsNull(compSeq[1]); Assert.AreSame(compSeq[2], Alphabets.DNA.A); Assert.AreSame(compSeq[3], Alphabets.DNA.C); Assert.AreSame(compSeq[4], Alphabets.DNA.G); #endregion Test - Complement #region Test - Reverse compSeq = sparseSeq.Reverse; Assert.AreEqual(compSeq.Count, 5); Assert.AreSame(compSeq[4], Alphabets.DNA.A); Assert.IsNull(compSeq[3]); Assert.AreSame(compSeq[2], Alphabets.DNA.T); Assert.AreSame(compSeq[1], Alphabets.DNA.G); Assert.AreSame(compSeq[0], Alphabets.DNA.C); #endregion Test - Reverse #region Test - ReverseComplement compSeq = sparseSeq.ReverseComplement; Assert.AreEqual(compSeq.Count, 5); Assert.AreSame(compSeq[4], Alphabets.DNA.T); Assert.IsNull(compSeq[3]); Assert.AreSame(compSeq[2], Alphabets.DNA.A); Assert.AreSame(compSeq[1], Alphabets.DNA.C); Assert.AreSame(compSeq[0], Alphabets.DNA.G); #endregion Test - ReverseComplement #region Test - IndexOfNotNull and LastIndexOfNotNull sparseSeq = new SparseSequence(Alphabets.DNA); sparseSeq.Count = 1000; sparseSeq[9] = null; sparseSeq[10] = Alphabets.DNA.Gap; sparseSeq[20] = Alphabets.DNA.GA; sparseSeq[501] = Alphabets.DNA.A; sparseSeq[905] = Alphabets.DNA.Gap; sparseSeq[906] = null; Assert.AreEqual(10, sparseSeq.IndexOfNotNull()); Assert.AreEqual(20, sparseSeq.IndexOfNotNull(10)); Assert.AreEqual(10, sparseSeq.IndexOfNotNull(9)); Assert.AreEqual(10, sparseSeq.IndexOfNotNull(0)); Assert.AreEqual(905, sparseSeq.IndexOfNotNull(501)); Assert.AreEqual(-1, sparseSeq.IndexOfNotNull(sparseSeq.Count)); Assert.AreEqual(905, sparseSeq.LastIndexOfNotNull()); Assert.AreEqual(501, sparseSeq.LastIndexOfNotNull(905)); Assert.AreEqual(905, sparseSeq.LastIndexOfNotNull(906)); Assert.AreEqual(905, sparseSeq.LastIndexOfNotNull(sparseSeq.Count)); Assert.AreEqual(10, sparseSeq.LastIndexOfNotNull(20)); Assert.AreEqual(-1, sparseSeq.LastIndexOfNotNull(10)); Assert.AreEqual(-1, sparseSeq.LastIndexOfNotNull(0)); sparseSeq = new SparseSequence(Alphabets.DNA); sparseSeq.Count = 1000; Assert.AreEqual(-1, sparseSeq.IndexOfNotNull()); Assert.AreEqual(-1, sparseSeq.IndexOfNotNull(10)); Assert.AreEqual(-1, sparseSeq.IndexOfNotNull(sparseSeq.Count)); Assert.AreEqual(-1, sparseSeq.LastIndexOfNotNull()); Assert.AreEqual(-1, sparseSeq.LastIndexOfNotNull(300)); Assert.AreEqual(-1, sparseSeq.LastIndexOfNotNull(sparseSeq.Count)); Assert.AreEqual(-1, sparseSeq.LastIndexOfNotNull(0)); #endregion Test - IndexOfNotNull and LastIndexOfNotNull #region Test - IndexOfNonGap and LastIndexOfNonGap sparseSeq = new SparseSequence(Alphabets.DNA); sparseSeq.Count = 1000; sparseSeq[9] = null; sparseSeq[10] = Alphabets.DNA.Gap; sparseSeq[20] = Alphabets.DNA.GA; sparseSeq[501] = Alphabets.DNA.A; sparseSeq[905] = Alphabets.DNA.Gap; sparseSeq[906] = null; Assert.AreEqual(20, sparseSeq.IndexOfNonGap()); Assert.AreEqual(20, sparseSeq.IndexOfNonGap(10)); Assert.AreEqual(20, sparseSeq.IndexOfNonGap(20)); Assert.AreEqual(501, sparseSeq.LastIndexOfNonGap()); Assert.AreEqual(501, sparseSeq.LastIndexOfNonGap(910)); Assert.AreEqual(501, sparseSeq.LastIndexOfNonGap(905)); Assert.AreEqual(501, sparseSeq.LastIndexOfNonGap(501)); #endregion Test - IndexOfNonGap and LastIndexOfNonGap }
/// <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); } }
public void ValidateDnaSparseSequenceProperties() { IAlphabet alphabet = Alphabets.DNA; // Create sparse sequence object const int insertPosition = 0; // Create sequence item list IList<byte> sequenceList = alphabet.ToList(); // Store sequence item in sparse sequence object using list of sequence items var sparseSequence = new SparseSequence(alphabet, insertPosition, sequenceList); //Validate all properties Assert.AreEqual(alphabet.Count + insertPosition, sparseSequence.Count); Assert.AreEqual(alphabet, sparseSequence.Alphabet); Assert.IsTrue(string.IsNullOrEmpty(sparseSequence.ID)); Assert.IsNotNull(sparseSequence.Metadata); Assert.IsNotNull(sparseSequence.Statistics); Assert.IsNotNull(sparseSequence.GetKnownSequenceItems()); ApplicationLog.WriteLine("SparseSequence BVT: Validation of all properties of sparse sequence instance is completed"); }
public void ValidateSparseSequenceGetKnownSequenceItems() { byte[] byteArrayObj = Encoding.ASCII.GetBytes("ACGT"); IEnumerable<byte> seqItems = new List<Byte> {byteArrayObj[0], byteArrayObj[1], byteArrayObj[2], byteArrayObj[3]}; var sparseSeqObj = new SparseSequence(Alphabets.DNA, 0, seqItems); IReadOnlyList<IndexedItem<byte>> revSeqObj = sparseSeqObj.GetKnownSequenceItems(); long i = 0; foreach (var by in revSeqObj) { Assert.AreEqual(i, by.Index); Assert.AreEqual(byteArrayObj[i], by.Item); i++; } ApplicationLog.WriteLine("SparseSequenceBVT: Validation of GetKnownSequenceItems() method successfully completed"); }
public void TestSparseSequence() { SparseSequence tempSeq = null; // Test constructors by passing invalid parameters. InvalidateSparseSequenceCtor(tempSeq); // Test constructor which takes only Alphabet for the IsReadOnly property. SparseSequence sparseSeq = new SparseSequence(Alphabets.DNA); InvalidateSparseSequenceCtorUsingAlphabet(sparseSeq); // Test editing with IsReadOnly set to true. sparseSeq = new SparseSequence(Alphabets.DNA, 0, Alphabets.DNA.A); string id = Guid.NewGuid().ToString(string.Empty); sparseSeq.ID = id; sparseSeq.DisplayID = "SparseSeq1"; InvalidateReadOnlySparseSequence(sparseSeq); #region Test not supported members string sequencedata = string.Empty; try { sequencedata = sparseSeq.ToString(); Assert.Fail(); } catch (NotSupportedException) { Assert.IsTrue(string.IsNullOrEmpty(sequencedata)); } #endregion Test not supported members Assert.AreEqual(sparseSeq.IndexOf(Alphabets.DNA.A), 0); Assert.AreSame(sparseSeq.Range(0, 1)[0], Alphabets.DNA.A); Assert.AreSame(sparseSeq.Reverse[0], Alphabets.DNA.A); Assert.AreSame(sparseSeq.ReverseComplement[0], Alphabets.DNA.T); Assert.IsTrue(sparseSeq.Contains(Alphabets.DNA.A)); ISequenceItem[] seqItemArray = new Nucleotide[10]; seqItemArray[0] = Alphabets.DNA.G; sparseSeq.CopyTo(seqItemArray, 1); Assert.AreSame(seqItemArray[0], Alphabets.DNA.G); Assert.AreSame(seqItemArray[1], Alphabets.DNA.A); try { sparseSeq.CopyTo(null, 1); Assert.Fail(); } catch (ArgumentNullException) { } Assert.IsTrue(sparseSeq.IsReadOnly); sparseSeq.IsReadOnly = false; // Test - void Add(ISequenceItem) InvalidateSparseSequenceAdd(sparseSeq); // Test - void Clear() InvalidateSparseSequenceClear(sparseSeq); // Test - void Insert(int position, char character) ValidateSparseSequenceInsert(sparseSeq); // Test - void Insert(int index, ISequenceItem item) ValidateSparseSequenceInsertSeqItem(sparseSeq); // Test - Count sparseSeq.Clear(); ValidateSparseSequenceCount(sparseSeq); // Test - void InsertRange(int position, string sequence) ValidateSparseSequenceInsertRange(sparseSeq); // Test - bool Remove(ISequenceItem item) ValidateSparseSequenceRemove(sparseSeq); // Test - void RemoveAt(int index) ValidateSparseSequenceRemoveAt(sparseSeq); // Test - void RemoveRange(int position, int length) ValidateSparseSequenceRemoveRange(sparseSeq); // Test - void Replace(int position, char character) ValidateSparseSequenceReplace(sparseSeq); // Test - void Replace(int position, ISequenceItem item) ValidateSparseSequenceReplaceSeqItem(sparseSeq); // Test - void ReplaceRange(int position, string sequence) ValidateSparseSequenceReplaceRange(sparseSeq); #region Test - ISequenceItem this[int index] sparseSeq[1] = null; Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.C); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); sparseSeq[0] = Alphabets.DNA.A; Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); try { sparseSeq[-1] = Alphabets.DNA.A; Assert.Fail(); } catch (ArgumentOutOfRangeException) { } try { sparseSeq[sparseSeq.Count] = Alphabets.DNA.A; Assert.Fail(); } catch (ArgumentOutOfRangeException) { } Assert.AreEqual(sparseSeq.Count, 5); Assert.AreSame(sparseSeq[0], Alphabets.DNA.A); Assert.IsNull(sparseSeq[1]); Assert.AreSame(sparseSeq[2], Alphabets.DNA.T); Assert.AreSame(sparseSeq[3], Alphabets.DNA.G); Assert.AreSame(sparseSeq[4], Alphabets.DNA.C); #endregion Test - ISequenceItem this[int index] #region Test - IList<IndexedSequenceItem> GetKnownSequenceItems IList <IndexedItem <ISequenceItem> > knownItems = sparseSeq.GetKnownSequenceItems(); Assert.AreEqual(knownItems.Count, 4); Assert.AreEqual(knownItems[0].Index, 0); Assert.AreSame(knownItems[0].Item, Alphabets.DNA.A); Assert.AreEqual(knownItems[1].Index, 2); Assert.AreSame(knownItems[1].Item, Alphabets.DNA.T); Assert.AreEqual(knownItems[2].Index, 3); Assert.AreSame(knownItems[2].Item, Alphabets.DNA.G); Assert.AreEqual(knownItems[3].Index, 4); Assert.AreSame(knownItems[3].Item, Alphabets.DNA.C); #endregion Test - IList<IndexedSequenceItem> GetKnownSequenceItems #region Test - IEnumerator<ISequenceItem> GetEnumerator() int i = 0; foreach (ISequenceItem item in sparseSeq) { Assert.AreSame(sparseSeq[i++], item); } #endregion Test - IEnumerator<ISequenceItem> GetEnumerator() // Test - Constructor by passing a sparse sequence. InvalidateSparseSequenceReverseComplement(sparseSeq); // Test - IndexOfNotNull and LastIndexOfNotNull sparseSeq = new SparseSequence(Alphabets.DNA); InvalidateSparseSequenceLastIndexOfNotNull(sparseSeq); // Test - IndexOfNonGap and LastIndexOfNonGap sparseSeq = new SparseSequence(Alphabets.DNA); InvalidateSparseSequenceIndexOfNonGap(sparseSeq); }
/// <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); } }