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);
}
}
