public void ValidateDnaSparseSequenceConstAlpIndex() { var sparseSeq = new SparseSequence(Alphabets.DNA, 0); Assert.IsNotNull(sparseSeq); Assert.AreEqual(0, sparseSeq.Count); Assert.IsNotNull(sparseSeq.Statistics); ApplicationLog.WriteLine("SparseSequence BVT: Validation of SparseSequence(alp, index) constructor is completed"); }
public void ValidateRnaSparseSequenceConstAlp() { var sparseSeq = new SparseSequence(Alphabets.RNA); Assert.IsNotNull(sparseSeq); Assert.AreEqual(0, sparseSeq.Count); Assert.IsNotNull(sparseSeq.Statistics); ApplicationLog.WriteLine("SparseSequence P1: Validation of SparseSequence(alp) constructor is completed"); }
public void ValidateDnaSparseSequenceConstAlpIndexByte() { byte[] byteArrayObj = Encoding.ASCII.GetBytes("AGCT"); var sparseSeq = new SparseSequence(Alphabets.DNA, 1, byteArrayObj[0]); Assert.IsNotNull(sparseSeq); Assert.IsNotNull(sparseSeq.Statistics); SequenceStatistics seqStatObj = sparseSeq.Statistics; Assert.AreEqual(1, seqStatObj.GetCount('A')); ApplicationLog.WriteLine("SparseSequence BVT: Validation of SparseSequence(alp, index, byte) constructor is completed"); }
public void TestSparseSequenceCopyTo() { IEnumerable<byte> seqItems = new List<Byte>() { 65, 65, 67, 67 }; SparseSequence sparseSeq = new SparseSequence(Alphabets.DNA, 0, seqItems); byte[] array = new byte[2]; sparseSeq.CopyTo(array, 1, 2); string expectedValue = "AC"; StringBuilder b = new StringBuilder(); b.Append((char)array[0]); b.Append((char)array[1]); string actualValue = b.ToString(); Assert.AreEqual(expectedValue, actualValue); }
public void ValidateSparseSequenceGetObjectData() { SerializationInfo info = new SerializationInfo(typeof(SparseSequence), new FormatterConverter()); StreamingContext context = new StreamingContext(StreamingContextStates.All); SparseSequence sparseSeqObj = CreateSparseSequence(Alphabets.DNA, 0); sparseSeqObj.GetObjectData(info, context); // Validate if there are no exceptions from the public method. Assert.IsNotNull(sparseSeqObj); Console.WriteLine( "SparseSequenceBVT: Validation of GetObjectData() is completed"); ApplicationLog.WriteLine( "SparseSequenceBVT: Validation of GetObjectData() is completed"); }
/// <summary> /// Invalidate Sparse sequence IndexOfNonGap /// </summary> /// <param name="sparseSeq">Sparse Sequence</param> private static void InvalidateSparseSequenceIndexOfNonGap(SparseSequence sparseSeq) { 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)); }
/// <summary> /// Invalidate Sparse sequence Add() /// </summary> /// <param name="sparseSeq">Sparse Sequence</param> private static void InvalidateSparseSequenceAdd(SparseSequence sparseSeq) { 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); } }
/// <summary> /// The common ParseOne method called for parsing sequences from Xsv files. /// This assumes that that the first line has been read into the XsvSparseReader /// (i.e. GoToNextLine() has been called). This adds the offset position present in /// the sequence start line to each position value in the sequence item. /// e.g. the following returns a sparse sequence with ID 'Test sequence' of length 100 /// with A at position 32 (25+7) and G at position 57 (50+7). /// # 7, 100, Test sequence /// 25,A /// 50,G /// </summary> /// <param name="sparseReader">The Xsv sparse reader that can read the sparse sequences. /// Flag to indicate whether the resulting sequence should be in readonly mode or not. /// If this flag is set to true then the resulting sequence's isReadOnly property /// will be set to true, otherwise it will be set to false. /// </param> /// <returns>The first sequence present starting from the /// current position in the reader as a SparseSequence. The sparse sequence has the ID present in the /// sequence start line, and its length equals the count present in that line. /// Null if EOF has been reached. Throws an exception if the current position did /// not have the sequence start line with the sequence prefix ID character. /// </returns> protected ISequence ParseOne(XsvSparseReader sparseReader) { // Check input arguments if (sparseReader == null) { throw new ArgumentNullException("sparseReader"); } if (!sparseReader.HasLines) { return(null); } if (sparseReader.SkipCommentLines || !sparseReader.HasCommentLine) { throw new InvalidDataException(Properties.Resource.XsvOffsetNotFound); } // create a new sparse sequence SparseSequence sequence = new SparseSequence(Alphabet); // read the sequence ID, count and offset sequence.ID = sparseReader.GetSequenceId(); long offset = sparseReader.GetSequenceOffset(); sequence.Count = sparseReader.GetSequenceCount() + offset; sequence.Metadata.Add(MetadataOffsetKey, offset); // go to first sequence item sparseReader.GoToNextLine(); while (sparseReader.HasLines && !sparseReader.HasCommentLine) { // add offset to position long position = long.Parse(sparseReader.Fields[0], CultureInfo.InvariantCulture) + offset; char symbol = sparseReader.Fields[1][0]; if (sequence.Count <= position) { sequence.Count = position + 1; } sequence[position] = (byte)symbol; sparseReader.GoToNextLine(); } return(sequence); }
public void ValidateSparseSequenceFindMatches() { ISequence seq = new Sequence(Alphabets.DNA, "ACCGGTT"); SparseSequence ssObj = new SparseSequence(Alphabets.DNA, 0, seq[0]); IList <string> patterns = new List <string>(); patterns.Add("A"); IDictionary <string, IList <int> > actual = ssObj.FindMatches(patterns, 0, false); Assert.AreEqual(1, actual.Count); Assert.AreEqual(0, actual["A"][0]); Console.WriteLine("Segmented Sequence : Successfully validated FindMatches() method."); ApplicationLog.WriteLine("Segmented Sequence : Successfully validated FindMatches() method."); }
public void ValidateSparseSequenceInvalidIndex() { SparseSequence sparseSeq = null; // Try Creating sparse sequence by passing invalid index. try { sparseSeq = new SparseSequence(Alphabets.DNA, -1, null); Assert.Fail(); } catch (ArgumentOutOfRangeException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
public void ValidateExceptionByPassingInvalidStartIndex() { //Create a sparse sequence. SparseSequence sparseSeq = new SparseSequence(Alphabets.DNA); // Try to add RNA Sequence Item to DNA sparse sequence. try { sparseSeq.GetSubSequence(10, 0); Assert.Fail(); } catch (ArgumentException) { Console.WriteLine( "SparseSequence P2: SparseSequence Exception was validated successfully"); } }
public void TestSparseSequenceGetKnownSequenceItems() { ISequence seq = new Sequence(Alphabets.DNA, "ATGC"); var sparseSeq = new SparseSequence(Alphabets.DNA, 0, seq); var 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); }
public void ValidateSparseSequenceInvalidSeqItem() { SparseSequence sparseSeq = null; // Try Creating sparse sequence by passing invalid sequence item. try { sparseSeq = new SparseSequence(Alphabets.DNA, 0, null); Assert.Fail(); } catch (ArgumentNullException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
/// <summary> /// The common ParseOne method called for parsing sequences from Xsv files. /// This assumes that that the first line has been read into the XsvSparseReader /// (i.e. GoToNextLine() has been called). This adds the offset position present in /// the sequence start line to each position value in the sequence item. /// e.g. the following returns a sparse sequence with ID 'Test sequence' of length 100 /// with A at position 32 (25+7) and G at position 57 (50+7). /// # 7, 100, Test sequence /// 25,A /// 50,G /// /// </summary> /// <param name="sparseReader">The Xsv sparse reader that can read the sparse sequences.</param> /// <param name="isReadOnly"> /// Flag to indicate whether the resulting sequence should be in readonly mode or not. /// If this flag is set to true then the resulting sequence's isReadOnly property /// will be set to true, otherwise it will be set to false. /// </param> /// <returns>The first sequence present starting from the /// current position in the reader as a SparseSequence. The sparse sequence has the ID present in the /// sequence start line, and its length equals the count present in that line. /// Null if EOF has been reached. Throws an exception if the current position did /// not have the sequence start line with the sequence prefix ID character. /// </returns> protected ISequence ParseOne(XsvSparseReader sparseReader, bool isReadOnly) { // Check input arguments if (sparseReader == null) { throw new ArgumentNullException("sparseReader", "Sparse reader to read sequence from cannot be null"); } if (!sparseReader.HasLines) { return(null); } if (sparseReader.SkipCommentLines || !sparseReader.HasCommentLine) { throw new InvalidDataException(Properties.Resource.XsvOffsetNotFound); } // create a new sparse sequence SparseSequence sequence = new SparseSequence(Alphabet); // read the sequence ID, count and offset sequence.ID = sparseReader.GetSequenceId(); sequence.Count = sparseReader.GetSequenceCount(); int offset = sparseReader.GetSequenceOffset(); // go to first sequence item sparseReader.GoToNextLine(); while (sparseReader.HasLines && !sparseReader.HasCommentLine) { // add offset to position int position = int.Parse(sparseReader.Fields[0], CultureInfo.InvariantCulture) + offset; char symbol = sparseReader.Fields[1][0]; if (sequence.Count <= position) { sequence.Count = position + 1; } sequence[position] = Alphabet.LookupBySymbol(symbol); sparseReader.GoToNextLine(); } sequence.IsReadOnly = isReadOnly; return(sequence); }
/// <summary> /// Creates a sparse sequence and inserts sequence items of alphabet. /// Delete all sequence items using Clear() method and /// validates if all items are deleted from sparse sequence object. /// </summary> /// <param name="alphabet">alphabet instance.</param> private void ValidateSparseSequenceClear(IAlphabet alphabet) { SparseSequence sparseSeq = CreateSparseSequence(alphabet, 10); sparseSeq.IsReadOnly = false; // Validate if sparse sequence conatins all sequence items. Assert.AreEqual(alphabet.Count + 10, sparseSeq.Count); // Clear the sparse sequence. sparseSeq.Clear(); // Validate if all sequence items are deleted. Assert.AreEqual(0, sparseSeq.Count); Console.WriteLine("SparseSequenceP1: Validation of Clear() method is completed"); ApplicationLog.WriteLine("SparseSequenceP1: Validation of Clear() method is completed"); }
/// <summary> /// The ParseOne method called for parsing sequences from Xsv files, /// and returning the offset separately. This can be used by aligned/assembled /// sparse sequences. /// This assumes that that the first line has been read into the XsvSparseReader /// (i.e. GoToNextLine() has been called). This does NOT add the offset position /// present in the sequence start line to each position value in the sequence item. /// Instead, it returns the offset in the out parameter. /// e.g. the following returns a sparse sequence with ID 'Test sequence' of length 100 /// with A at position 25 and G at position 50, /// and the out offset value as 7. /// # 7, 100, Test sequence /// 25,A /// 50,G /// /// </summary> /// <param name="sparseReader">The Xsv sparse reader that can read the sparse sequences.</param> /// <param name="isReadOnly"> /// Flag to indicate whether the resulting sequence should be in readonly mode or not. /// If this flag is set to true then the resulting sequence's isReadOnly property /// will be set to true, otherwise it will be set to false. /// </param> /// <returns>The first sequence present starting from the /// current position in the reader, as a SparseSequence. The sparse sequence has the ID present in the /// sequence start line, and its length equals the count present in that line. /// Throws an exception if EOF has been reached or the current position did /// not have the sequence start line with the sequence prefix ID character. /// Also returns the offset value present in the sequence start line. /// </returns> protected Tuple <ISequence, int> ParseOneWithOffset(XsvSparseReader sparseReader, bool isReadOnly) { if (sparseReader == null) { throw new ArgumentNullException("sparseReader"); } int offset = -1; if (!sparseReader.HasLines) { return(null); } if (sparseReader.SkipCommentLines || !sparseReader.HasCommentLine) { throw new InvalidDataException(Properties.Resource.XsvOffsetNotFound); } // create a new sparse sequence SparseSequence sequence = new SparseSequence(Alphabet); // read the sequence ID and offset sequence.ID = sparseReader.GetSequenceId(); sequence.Count = sparseReader.GetSequenceCount(); offset = sparseReader.GetSequenceOffset(); sparseReader.GoToNextLine(); while (sparseReader.HasLines && !sparseReader.HasCommentLine) { int position = int.Parse(sparseReader.Fields[0], CultureInfo.InvariantCulture); char symbol = sparseReader.Fields[1][0]; if (sequence.Count <= position) { sequence.Count = position + 1; } sequence[position] = Alphabet.LookupBySymbol(symbol); sparseReader.GoToNextLine(); } sequence.IsReadOnly = isReadOnly; return(Tuple.Create((ISequence)sequence, offset)); }
/// <summary> /// Creates a sparse sequence and inserts sequence items of alphabet /// and removes few sequence items using RemoveRange() /// Validates ifexpected number of items are removed. /// </summary> /// <param name="alphabet">alphabet instance.</param> private void ValidateSparseSequenceRemoveRange(IAlphabet alphabet) { SparseSequence sparseSequence = CreateSparseSequence(alphabet, 10); sparseSequence.IsReadOnly = false; // Remove all sequence items Assert.AreEqual(alphabet.Count + 10, sparseSequence.Count); sparseSequence.RemoveRange(10, 10); // Validate if 10 items are removed using RemoveRange Assert.AreEqual(alphabet.Count, sparseSequence.Count); Console.WriteLine( "SparseSequenceP1: Validation of RemoveRange() method by passing position and length is completed"); ApplicationLog.WriteLine( "SparseSequenceP1: Validation of RemoveRange() method by passing position and length is completed"); }
public void ValidateSparseSequenceGetReversedComplementedSequence() { 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); ISequence revSeqObj = sparseSeqObj.GetReverseComplementedSequence(); for (int i = 0; i < byteArrayObj.Length; i++) { Assert.AreEqual(byteArrayObj[i], revSeqObj[i]); } ApplicationLog.WriteLine("SparseSequenceBVT: Validation of GetReverseComplementedSequence() method successfully completed"); }
public void ValidateRnaSparseSequenceConstAlpIndexByteList() { byte[] byteArrayObj = Encoding.ASCII.GetBytes("AGCU"); IEnumerable<byte> seqItems = new List<Byte> {byteArrayObj[0], byteArrayObj[1], byteArrayObj[2], byteArrayObj[3]}; var sparseSeq = new SparseSequence(Alphabets.RNA, 4, seqItems); Assert.IsNotNull(sparseSeq); Assert.IsNotNull(sparseSeq.Statistics); Assert.AreEqual(8, sparseSeq.Count); SequenceStatistics seqStatObj = sparseSeq.Statistics; Assert.AreEqual(1, seqStatObj.GetCount('A')); Assert.AreEqual(1, seqStatObj.GetCount('G')); Assert.AreEqual(1, seqStatObj.GetCount('C')); Assert.AreEqual(1, seqStatObj.GetCount('U')); ApplicationLog.WriteLine("SparseSequence P1: Validation of SparseSequence(alp, index, seq items) constructor is completed"); }
/// <summary> /// Invalidate Sparse sequence Remove /// </summary> /// <param name="sparseSeq">Sparse Sequence</param> private static void ValidateSparseSequenceRemove(SparseSequence sparseSeq) { 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); }
public void TestSparseSequenceCopyTo() { IEnumerable <byte> seqItems = new List <Byte>() { 65, 65, 67, 67 }; SparseSequence sparseSeq = new SparseSequence(Alphabets.DNA, 0, seqItems); byte[] array = new byte[2]; sparseSeq.CopyTo(array, 1, 2); string expectedValue = "AC"; StringBuilder b = new StringBuilder(); b.Append((char)array[0]); b.Append((char)array[1]); string actualValue = b.ToString(); Assert.AreEqual(expectedValue, actualValue); }
public void ValidateSparseSequenceInvalidAlphabet() { SparseSequence sparseSeq = null; var seq = new Sequence(Alphabets.RNA, "U"); byte seqItem = seq[0]; // Try Creating sparse sequence by passing invalid alphabet. try { sparseSeq = new SparseSequence(Alphabets.DNA, 0, seqItem); Assert.Fail(); } catch (ArgumentException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
/// <summary> /// The common ParseOne method called for parsing SNPs /// NOTE: The snpReader.MoveNext must have already been called and /// the ISnpReader.Current have the first SnpItem to parse into the sequence /// </summary> /// <param name="snpReader">The ISnpReader to read a Snp chromosome sequence from</param> /// <param name="isReadOnly"> /// Flag to indicate whether the resulting sequence should be in readonly mode or not. /// If this flag is set to true then the resulting sequence's isReadOnly property /// will be set to true, otherwise it will be set to false. /// </param> /// <returns>Returns a SparseSequence containing Snp items from the first contiguous /// chromosome number read from the snp reader.</returns> protected ISequence ParseOne(ISnpReader snpReader, bool isReadOnly) { // Check input arguments if (snpReader == null) { throw new ArgumentNullException("snpReader", "SNP Reader to read SNP sequences from cannot be null"); } if (snpReader.Current == null) { return new SparseSequence(Alphabet) { ID = "Empty" } } ; int sequenceChromosome = snpReader.Current.Chromosome; SparseSequence sequence = new SparseSequence(Alphabet); sequence.ID = ("Chr" + sequenceChromosome); do { SnpItem snp = snpReader.Current; // increase the size of the sparse sequence if (sequence.Count <= snp.Position) { sequence.Count = snp.Position + 1; } sequence[snp.Position] = ParseAlleleOne ? Alphabet.LookupBySymbol(snp.AlleleOne) : Alphabet.LookupBySymbol(snp.AlleleTwo); } while (snpReader.MoveNext() && snpReader.Current.Chromosome == sequenceChromosome); sequence.IsReadOnly = isReadOnly; return(sequence); } #endregion Protected Methods of SnpParser }
public void ValidateSparseSequenceIndexOfNonGap() { SparseSequence sparseSeqObj = new SparseSequence(Alphabets.DNA); sparseSeqObj.Count = 1000; sparseSeqObj[9] = null; sparseSeqObj[10] = Alphabets.DNA.Gap; sparseSeqObj[20] = Alphabets.DNA.GA; sparseSeqObj[501] = Alphabets.DNA.A; sparseSeqObj[905] = Alphabets.DNA.Gap; sparseSeqObj[906] = null; Assert.AreEqual(20, sparseSeqObj.IndexOfNonGap()); Assert.AreEqual(20, sparseSeqObj.IndexOfNonGap(10)); Assert.AreEqual(20, sparseSeqObj.IndexOfNonGap(20)); Console.WriteLine( "SparseSequenceBVT: Validation of IndexOfNonGap() method successfully completed"); ApplicationLog.WriteLine( "SparseSequenceBVT: Validation of IndexOfNonGap() method successfully completed"); }
/// <summary> /// Invalidate Sparse sequence Comp & ReverseComplement /// </summary> /// <param name="sparseSeq">Sparse Sequence</param> private static void InvalidateSparseSequenceReverseComplement(SparseSequence sparseSeq) { SparseSequence 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); #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 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); }
/// <summary> /// The common ParseOne method called for parsing SNPs /// NOTE: The snpReader.MoveNext must have already been called and /// the ISnpReader.Current have the first SnpItem to parse into the sequence /// </summary> /// <param name="snpReader">The ISnpReader to read a Snp chromosome sequence from</param> /// <returns>Returns a SparseSequence containing Snp items from the first contiguous /// chromosome number read from the snp reader.</returns> protected ISequence ParseOne(ISnpReader snpReader) { // Check input arguments if (snpReader == null) { throw new ArgumentNullException("snpReader", Properties.Resource.snpTextReaderNull); } if (snpReader.Current == null) { return new SparseSequence(Alphabet) { ID = "Empty" } } ; int sequenceChromosome = snpReader.Current.Chromosome; SparseSequence sequence = new SparseSequence(Alphabet); sequence.ID = ("Chr" + sequenceChromosome); do { SnpItem snp = snpReader.Current; // increase the size of the sparse sequence if (sequence.Count <= snp.Position) { sequence.Count = snp.Position + 1; } sequence[snp.Position] = ParseAlleleOne ? (byte)snp.AlleleOne : (byte)snp.AlleleTwo; } while (snpReader.MoveNext() && snpReader.Current.Chromosome == sequenceChromosome); return(sequence); } #endregion Protected Methods of SnpParser }
/// <summary> /// Creates a sparse sequence and inserts sequence items at even position of alphabet /// and replace the sequence item with sequence item symbol present at odd position. /// Validates if item is replaced. /// </summary> /// <param name="alphabet">alphabet instance.</param> private void ValidateSparseSequenceReplaceWithChar(IAlphabet alphabet) { // Create sequence item array ISequenceItem[] sequenceItemArray = new ISequenceItem[alphabet.Count]; int index = 0; foreach (ISequenceItem item in alphabet) { sequenceItemArray[index] = item; index++; } /// Validate the Replace method with char /// Add even sequence items from sequence item array at random position /// and replace with odd sequence item symbol from array. int replaceIndex = 1; int[] randomNumbers = Utility.RandomNumberGenerator(1502, alphabet.Count); index = 0; for (int addIndex = 0; addIndex < alphabet.Count; addIndex = addIndex + 2) { SparseSequence sparseSeq = new SparseSequence(alphabet, randomNumbers[index], sequenceItemArray[addIndex]); sparseSeq.IsReadOnly = false; sparseSeq.Replace(randomNumbers[index], sequenceItemArray[replaceIndex].Symbol); // Validate if item is replaced as expected. Assert.AreEqual(sparseSeq[randomNumbers[index]].Symbol, sequenceItemArray[replaceIndex].Symbol); Assert.AreEqual(sparseSeq[randomNumbers[index]], sequenceItemArray[replaceIndex]); replaceIndex = replaceIndex + 2; index++; } Console.WriteLine( "SparseSequenceBVT: Validation of Replace() method by passing char is completed"); ApplicationLog.WriteLine( "SparseSequenceBVT: Validation of Replace() method by passing char is completed"); }
/// <summary> /// Creates a sparse sequence and inserts sequence items of alphabet /// and removes all sequence items. /// Validates if items are getting removed. /// </summary> /// <param name="alphabet">alphabet instance.</param> private void ValidateSparseSequenceRemove(IAlphabet alphabet) { SparseSequence sparseSequence = CreateSparseSequence(alphabet, 0); sparseSequence.IsReadOnly = false; // Remove all sequence items Assert.AreEqual(alphabet.Count, sparseSequence.Count); foreach (ISequenceItem item in alphabet) { sparseSequence.Remove(item); } // Validate if all items are removed. Assert.AreEqual(0, sparseSequence.Count); Console.WriteLine( "SparseSequenceBVT: Validation of Replace() method by passing char is completed"); ApplicationLog.WriteLine( "SparseSequenceBVT: Validation of Replace() method by passing char is completed"); }
public void ValidateSparseSequenceListInvalidIndex() { SparseSequence sparseSeq = null; var seq = new Sequence(Alphabets.DNA, "G"); var seqItemList = new List <byte> { seq[0] }; // Try Creating sparse sequence by passing invalid index. try { sparseSeq = new SparseSequence(Alphabets.DNA, -1, seqItemList); Assert.Fail(); } catch (ArgumentOutOfRangeException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
/// <summary> /// Test Sparse sequence constructor using alphabet /// </summary> /// <param name="sparseSeq">Sparse Sequence</param> private static void InvalidateSparseSequenceCtorUsingAlphabet(SparseSequence sparseSeq) { 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"; 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); }
public void ValidateSparseSequenceSetIndexer() { IAlphabet alphabet = Alphabets.DNA; // Create sequence item list var sequenceList = new List <byte>(); foreach (byte item in alphabet) { sequenceList.Add(item); } // Store sequence item in sparse sequence object using list of sequence items var sparseSeq = new SparseSequence(alphabet, 0, sequenceList); byte seqItem = new Sequence(Alphabets.DNA, "AGCT")[0]; sparseSeq[0] = seqItem; Assert.AreEqual(65, sparseSeq[0]); ApplicationLog.WriteLine("SparseSequence BVT: Validation of Indexer successfully completed"); }
public void ValidateSparseSequenceListInvalidAlphabet() { SparseSequence sparseSeq = null; Sequence seq = new Sequence(Alphabets.RNA, "U"); List <byte> seqItemList = new List <byte>(); seqItemList.Add(seq[0]); // Try Creating sparse sequence by passing Invalid alphabet try { sparseSeq = new SparseSequence(Alphabets.DNA, 0, seqItemList); Assert.Fail(); } catch (ArgumentException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
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); IList <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"); }
/// <summary> /// Creates sparse sequence object using seq item list overload. /// Validates if all items are present in sparse sequence instance. /// </summary> /// <param name="alphabet">alphabet instance.</param> private void ValidateSparseSequenceWithSeqItemList(IAlphabet alphabet) { SparseSequence sparseSeq = CreateSparseSequence(alphabet, 20); // Retrieve all stored sequence items and validate Sparse Sequence int retrieveIndex = 20; foreach (ISequenceItem item in alphabet) { // Validate new added items Assert.IsTrue(sparseSeq.Contains(item)); Assert.AreEqual(sparseSeq.IndexOf(item), retrieveIndex); Assert.AreEqual(item, sparseSeq[retrieveIndex]); Assert.AreEqual(item.Symbol, sparseSeq[retrieveIndex].Symbol); retrieveIndex++; } Console.WriteLine( "SparseSequenceP1: Validation of Sparse Sequence constructor with Sequence item list is completed"); ApplicationLog.WriteLine( "SparseSequenceP1: Validation of Sparse Sequence constructor with Sequence item list is completed"); }
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 ValidateSparseSeqNegativeIndexException() { string expectedErrorMessage = this.GetErrorMessage(Constants.NegativeIndexErrorMessage); string actualError = string.Empty; SparseSequence sparseSeq = null; // Try Creating sparse sequence by passing null value. try { sparseSeq = new SparseSequence(Alphabets.DNA, -5, Alphabets.DNA.A); } catch (ArgumentException e) { actualError = e.Message; } string updatedActualError = Regex.Replace(actualError, "[\r\n\t]", ""); Assert.AreEqual(expectedErrorMessage.ToUpperInvariant(), updatedActualError.ToUpperInvariant()); Assert.IsNull(sparseSeq); // Log to GUI. ApplicationLog.WriteLine(string.Format(null, "SparseSequence P2: SparseSequence Exception was validated successfully {0}", updatedActualError)); }
public void ValidateSparseSequenceIndexOfNonGap() { var sparseSeqObj = new SparseSequence(Alphabets.DNA, 10); sparseSeqObj[8] = Alphabets.DNA.Gap; sparseSeqObj[9] = Alphabets.DNA.A; Assert.AreEqual(9, sparseSeqObj.IndexOfNonGap(8)); Assert.AreEqual(9, sparseSeqObj.IndexOfNonGap(9)); ApplicationLog.WriteLine("SparseSequenceBVT: Validation of IndexOfNonGap(startPos) method successfully completed"); }
public void ValidateSparseSequenceGetSubSequence() { var byteList = new List<byte> { Alphabets.DNA.Gap, Alphabets.DNA.G, Alphabets.DNA.A, Alphabets.DNA.Gap, Alphabets.DNA.T, Alphabets.DNA.C, Alphabets.DNA.Gap, Alphabets.DNA.Gap }; var sparseSeq = new SparseSequence(Alphabets.DNA, 0, byteList); ISequence result = sparseSeq.GetSubSequence(0, 3); Assert.AreEqual(3, result.Count); Assert.AreEqual(Alphabets.DNA.Gap, result[0]); Assert.AreEqual(Alphabets.DNA.G, result[1]); Assert.AreEqual(Alphabets.DNA.A, result[2]); result = sparseSeq.GetSubSequence(0, 0); Assert.AreEqual(0, result.Count); result = sparseSeq.GetSubSequence(3, 2); Assert.AreEqual(2, result.Count); Assert.AreEqual(Alphabets.DNA.Gap, result[0]); Assert.AreEqual(Alphabets.DNA.T, result[1]); ApplicationLog.WriteLine("SparseSequenceBVT: Validation of GetSubSequence() method successfully completed"); }
public void ValidateSparseSequenceGetComplementedSequence() { 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); ISequence revSeqObj = sparseSeqObj.GetComplementedSequence(); byteArrayObj = Encoding.ASCII.GetBytes("TGCA"); for (int i = 0; i < byteArrayObj.Length; i++) { Assert.AreEqual(byteArrayObj[i], revSeqObj[i]); } ApplicationLog.WriteLine("SparseSequenceBVT: Validation of GetComplementedSequence() method successfully completed"); }
public void ValidateExceptionByPassingInvalidLength() { //Create a sparse sequence. var sparseSeq = new SparseSequence(Alphabets.DNA, 5); try { sparseSeq.GetSubSequence(0, 10); Assert.Fail(); } catch (ArgumentException) { // Log to GUI. ApplicationLog.WriteLine("SparseSequence P2: SparseSequence Exception was validated successfully"); } }
/// <summary> /// The common ParseOne method called for parsing SNPs /// NOTE: The snpReader.MoveNext must have already been called and /// the ISnpReader.Current have the first SnpItem to parse into the sequence /// </summary> /// <param name="snpReader">The ISnpReader to read a Snp chromosome sequence from</param> /// <returns>Returns a SparseSequence containing Snp items from the first contiguous /// chromosome number read from the snp reader.</returns> protected ISequence ParseOne(ISnpReader snpReader) { // Check input arguments if (snpReader == null) { throw new ArgumentNullException("snpReader",Properties.Resource.snpTextReaderNull); } if (snpReader.Current == null) return new SparseSequence(Alphabet) { ID = "Empty" }; int sequenceChromosome = snpReader.Current.Chromosome; SparseSequence sequence = new SparseSequence(Alphabet) { ID = "Chr" + sequenceChromosome }; do { SnpItem snp = snpReader.Current; // increase the size of the sparse sequence if (sequence.Count <= snp.Position) sequence.Count = snp.Position + 1; sequence[snp.Position] = ParseAlleleOne ? (byte)snp.AlleleOne : (byte)snp.AlleleTwo; } while (snpReader.MoveNext() && snpReader.Current.Chromosome == sequenceChromosome); return sequence; }
/// <summary> /// The common ParseOne method called for parsing sequences from Xsv files. /// This assumes that that the first line has been read into the XsvSparseReader /// (i.e. GoToNextLine() has been called). This adds the offset position present in /// the sequence start line to each position value in the sequence item. /// e.g. the following returns a sparse sequence with ID 'Test sequence' of length 100 /// with A at position 32 (25+7) and G at position 57 (50+7). /// # 7, 100, Test sequence /// 25,A /// 50,G /// </summary> /// <param name="sparseReader">The Xsv sparse reader that can read the sparse sequences. /// Flag to indicate whether the resulting sequence should be in readonly mode or not. /// If this flag is set to true then the resulting sequence's isReadOnly property /// will be set to true, otherwise it will be set to false. /// </param> /// <returns>The first sequence present starting from the /// current position in the reader as a SparseSequence. The sparse sequence has the ID present in the /// sequence start line, and its length equals the count present in that line. /// Null if EOF has been reached. Throws an exception if the current position did /// not have the sequence start line with the sequence prefix ID character. /// </returns> protected ISequence ParseOne(XsvSparseReader sparseReader) { // Check input arguments if (sparseReader == null) { throw new ArgumentNullException("sparseReader"); } if (!sparseReader.HasLines) return null; if (sparseReader.SkipCommentLines || !sparseReader.HasCommentLine) throw new InvalidDataException(Properties.Resource.XsvOffsetNotFound); // create a new sparse sequence SparseSequence sequence = new SparseSequence(Alphabet) { ID = sparseReader.GetSequenceId() }; // read the sequence ID, count and offset long offset = sparseReader.GetSequenceOffset(); sequence.Count = sparseReader.GetSequenceCount() + offset; sequence.Metadata.Add(MetadataOffsetKey, offset); // go to first sequence item sparseReader.GoToNextLine(); while (sparseReader.HasLines && !sparseReader.HasCommentLine) { // add offset to position long position = long.Parse(sparseReader.Fields[0], CultureInfo.InvariantCulture) + offset; char symbol = sparseReader.Fields[1][0]; if (sequence.Count <= position) sequence.Count = position + 1; sequence[position] = (byte)symbol; sparseReader.GoToNextLine(); } return sequence; }
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 ValidateIndexValueOfDifferentSeqItemOtherThanSparseSeqItem() { // Create a sparse sequence. var sparseSeq = new SparseSequence(Alphabets.DNA) {Count = 2000}; // Store all sequence items in sparse sequence object int insertIndex = 0; int[] randomNumbers = Utility.RandomNumberGenerator(2000, Alphabets.DNA.Count); foreach (byte item in Alphabets.DNA) { sparseSeq[randomNumbers[insertIndex]] = item; insertIndex++; } foreach (byte bt in sparseSeq) { Assert.AreNotEqual(bt, Alphabets.RNA.U); } // Log to GUI. ApplicationLog.WriteLine("SparseSequence P2: SparseSequence Exception was validated successfully"); }
public void ValidateExceptionByPassingSeqItemToInvalidSequenceItemPostion() { string expectedErrorMessage = this.GetErrorMessage(Constants.InvalidSequenceCountError); string actualError = string.Empty; var sparseSeq = new SparseSequence(Alphabets.DNA) {Count = 1000}; // Try to store seq items at 1050 position greater than sparse // sequence count. try { sparseSeq[1050] = Alphabets.DNA.A; } catch (ArgumentOutOfRangeException e) { actualError = e.Message; } string updatedActualError = Regex.Replace(actualError, "[\r\n\t]", ""); Assert.AreEqual(expectedErrorMessage.ToUpperInvariant(), updatedActualError.ToUpperInvariant()); // Log to GUI. ApplicationLog.WriteLine(string.Format(null, "SparseSequence P2: SparseSequence Exception was validated successfully {0}", updatedActualError)); }
public void ValidateSeqItemsByPassingProteinSeqItemToRnaSequence() { var sparseSeq = new SparseSequence(Alphabets.RNA) {Count = 2000}; // Store all sequence items in sparse sequence object int insertIndex = 0; int[] randomNumbers = Utility.RandomNumberGenerator(2000, Alphabets.RNA.Count); foreach (byte item in Alphabets.RNA) { sparseSeq[randomNumbers[insertIndex]] = item; insertIndex++; } // Validate whether invalid sequence item contains in Sparse // sequence or not. foreach (byte bt in sparseSeq) { Assert.AreNotEqual(bt, Alphabets.Protein.D); } ApplicationLog.WriteLine("SparseSequence P2: SparseSequence error was validated successfully."); }
public void TestSparseSequenceConstructorWithSequenceArgument() { IEnumerable<byte> seqItems = new List<Byte>() { 65, 65, 67, 67 }; SparseSequence sparseSeq = new SparseSequence(Alphabets.DNA, 0, seqItems); ISequence seq = sparseSeq.GetSubSequence(0, sparseSeq.Count); SparseSequence newSparseSequence = new SparseSequence(seq); ISequence newSeq = newSparseSequence.GetSubSequence(0, newSparseSequence.Count); string expectedValue = "AACC"; string actualValue = new string(newSeq.Select(x => (char)x).ToArray()); Assert.AreEqual(expectedValue, actualValue); }
public void ValidateSparseSequenceGetEnumerator() { 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); IEnumerator<byte> seqObj = sparseSeqObj.GetEnumerator(); int i = 0; while (seqObj.MoveNext()) { Assert.AreEqual(byteArrayObj[i], seqObj.Current); i++; } i = 0; foreach (byte alp in sparseSeqObj) { Assert.AreEqual(byteArrayObj[i], alp); i++; } ApplicationLog.WriteLine("SparseSequenceBVT: Validation of GetEnumerator() method successfully completed"); }
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 ValidateSparseSequenceSetIndexer() { IAlphabet alphabet = Alphabets.DNA; // Create sequence item list var sequenceList = new List<byte>(); foreach (byte item in alphabet) { sequenceList.Add(item); } // Store sequence item in sparse sequence object using list of sequence items var sparseSeq = new SparseSequence(alphabet, 0, sequenceList); byte seqItem = new Sequence(Alphabets.DNA, "AGCT")[0]; sparseSeq[0] = seqItem; Assert.AreEqual(65, sparseSeq[0]); ApplicationLog.WriteLine("SparseSequence BVT: Validation of Indexer successfully completed"); }
public void InvalidateCopyTo() { var byteList = new List<byte> { Alphabets.DNA.Gap, Alphabets.DNA.G, Alphabets.DNA.A, Alphabets.DNA.Gap, Alphabets.DNA.T, Alphabets.DNA.C, Alphabets.DNA.Gap, Alphabets.DNA.Gap }; ISequence iSeq = new SparseSequence(Alphabets.DNA, 0, byteList); var seqObj = new SparseSequence(iSeq); //check with null array byte[] array = null; try { seqObj.CopyTo(array, 10, 20); Assert.Fail(); } catch (ArgumentNullException anex) { ApplicationLog.WriteLine("Successfully caught ArgumentNullException : " + anex.Message); } //check with more than available length array = new byte[byteList.Count]; try { seqObj.CopyTo(array, 0, byteList.Count + 100); Assert.Fail(); } catch (ArgumentException aex) { ApplicationLog.WriteLine("Successfully caught ArgumentException : " + aex.Message); } //check with negative start array = new byte[byteList.Count]; try { seqObj.CopyTo(array, -5, byteList.Count); Assert.Fail(); } catch (ArgumentException aex) { ApplicationLog.WriteLine("Successfully caught ArgumentException : " + aex.Message); } //check with negative count array = new byte[byteList.Count]; try { seqObj.CopyTo(array, 0, -5); Assert.Fail(); } catch (ArgumentException aex) { ApplicationLog.WriteLine("Successfully caught ArgumentException : " + aex.Message); } }
/// <summary> /// Create sparse sequence and insert all sequence items of alphabet. /// </summary> /// <param name="alphabet"></param> /// <param name="insertPosition"></param> /// <returns></returns> private static SparseSequence CreateSparseSequence(IAlphabet alphabet, int insertPosition) { // Create sequence item list var sequenceList = alphabet.ToList(); // Store sequence item in sparse sequence object using list of sequence items var sparseSeq = new SparseSequence(alphabet, insertPosition, sequenceList); return sparseSeq; }
public void ValidateSparseSequenceLastIndexOfNonGapNull() { var sparseSeqObj = new SparseSequence(Alphabets.DNA, 2); sparseSeqObj[1] = Alphabets.DNA.Gap; sparseSeqObj[0] = Alphabets.DNA.A; Assert.AreEqual(0, sparseSeqObj.LastIndexOfNonGap()); ApplicationLog.WriteLine("SparseSequenceBVT: Validation of LastIndexOfNonGap() method successfully completed"); }
public void ValidateSparseSequenceListInvalidIndex() { SparseSequence sparseSeq = null; var seq = new Sequence(Alphabets.DNA, "G"); var seqItemList = new List<byte> {seq[0]}; // Try Creating sparse sequence by passing invalid index. try { sparseSeq = new SparseSequence(Alphabets.DNA, -1, seqItemList); Assert.Fail(); } catch (ArgumentOutOfRangeException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
public void ValidateExceptionByPassingInvalidStartIndex() { //Create a sparse sequence. var sparseSeq = new SparseSequence(Alphabets.DNA); // Try to add RNA Sequence Item to DNA sparse sequence. try { sparseSeq.GetSubSequence(10, 0); Assert.Fail(); } catch (ArgumentException) { ApplicationLog.WriteLine("SparseSequence P2: SparseSequence Exception was validated successfully"); } }
public void ValidateSparseSequenceListInvalidAlphabet() { SparseSequence sparseSeq = null; var seq = new Sequence(Alphabets.RNA, "U"); var seqItemList = new List<byte> {seq[0]}; // Try Creating sparse sequence by passing Invalid alphabet try { sparseSeq = new SparseSequence(Alphabets.DNA, 0, seqItemList); Assert.Fail(); } catch (ArgumentException ex) { LogMessage(ex.Message); } Assert.IsNull(sparseSeq); }
public void ValidateCopyTo() { var byteList = new List<byte> { Alphabets.DNA.Gap, Alphabets.DNA.G, Alphabets.DNA.A, Alphabets.DNA.Gap, Alphabets.DNA.T, Alphabets.DNA.C, Alphabets.DNA.Gap, Alphabets.DNA.Gap }; ISequence iSeq = new SparseSequence(Alphabets.DNA, 0, byteList); var sparseSeq = new SparseSequence(iSeq); var array = new byte[byteList.Count]; sparseSeq.CopyTo(array, 0, byteList.Count); for (int i = 0; i < byteList.Count; i++) { Assert.AreEqual(byteList.ElementAt(i), array[i]); } //check for a part of the sequence array = new byte[5]; sparseSeq.CopyTo(array, 0, 5); for (int i = 0; i < 5; i++) { Assert.AreEqual(byteList.ElementAt(i), array[i]); } }