public void ValidateVQSLCopyTo()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQNode);
ICollection <ISequence> seqCopy = seqList;
int i = seqCopy.Count;
IQualitativeSequence[] seqArray = new IQualitativeSequence[i];
seqList.CopyTo(seqArray, 0);
Assert.AreEqual(seqList[0].ToString(),
seqArray[0].ToString());
Assert.AreEqual(seqList[i - 1].ToString(),
seqArray[i - 1].ToString());
seqCopy.CopyTo(seqArray, 0);
Assert.AreEqual(seqList[0].ToString(),
seqArray[0].ToString());
Assert.AreEqual(seqList[i - 1].ToString(),
seqArray[i - 1].ToString());
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the CopyTo() method");
Console.WriteLine(
"VQSL Bvt : Successfully validated the CopyTo() method");
}
/// <summary>
/// Writes an IQualitativeSequence to the specified text writer.
/// </summary>
/// <param name="qualSequence">The QualitativeSequence to format.</param>
/// <param name="writer">The TextWriter used to write the formatted sequence text.</param>
public void Format(IQualitativeSequence qualSequence, TextWriter writer)
{
if (qualSequence == null)
{
throw new ArgumentNullException(Resource.ParameterNameQualSequence);
}
if (writer == null)
{
throw new ArgumentNullException(Resource.ParameterNameWriter);
}
string header = qualSequence.ID;
string lengthStr = " length=";
if (qualSequence.ID.Contains(lengthStr))
{
int startIndex = qualSequence.ID.LastIndexOf(lengthStr);
header = header.Substring(0, startIndex + 8) + qualSequence.Count;
}
writer.WriteLine("@" + header);
writer.WriteLine(qualSequence.ToString());
writer.WriteLine("+" + header);
writer.WriteLine(ASCIIEncoding.ASCII.GetString(qualSequence.Scores));
writer.Flush();
}
/// <summary>
/// Writes an IQualitativeSequence to the specified file.
/// </summary>
/// <param name="qualSequence">The QualitativeSequence to format.</param>
/// <param name="fileName">The name of the file to write the formatted sequence text.</param>
public void Format(IQualitativeSequence qualSequence, string fileName)
{
using (TextWriter writer = new StreamWriter(fileName))
{
Format(qualSequence, writer);
}
}
/// <summary>
/// Converts an IQualitativeSequence to a formatted text.
/// </summary>
/// <param name="qualSequence">The QualitativeSequence to format.</param>
/// <returns>A string of the formatted text.</returns>
public string FormatString(IQualitativeSequence qualSequence)
{
using (TextWriter writer = new StringWriter())
{
Format(qualSequence, writer);
return(writer.ToString());
}
}
/// <summary>
/// Returns the index of the first sequence matching the sequence
/// passed in to the parameter. This does not do a value-based
/// comparison. The match must be the exact same IQualitativeSequence.
/// </summary>
/// <returns>the zero-based index of the sequence if found; otherwise, -1</returns>
public int IndexOf(IQualitativeSequence item)
{
foreach (var entry in _sequenceDictionary)
{
if (ReferenceEquals(item, entry.Value.Target))
{
return(entry.Key);
}
}
return(-1);
}
/// <summary>
/// Gets quality values.
/// </summary>
public byte[] GetQualityValues()
{
IQualitativeSequence seq = QuerySequence as IQualitativeSequence;
if (seq != null)
{
return(seq.Scores);
}
else
{
return(new byte[0]);
}
}
public void TestFastQWhenParsingOneOfMany()
{
// parse
ISequenceParser parser = new FastQParser();
string filepath = @"testdata\FASTQ\SRR002012_5.fastq";
ISequence seq = parser.ParseOne(filepath);
FastQParser fqParser = new FastQParser();
fqParser.AutoDetectFastQFormat = false;
fqParser.FastqType = FastQFormatType.Sanger;
IQualitativeSequence qualSeq = fqParser.ParseOne(filepath);
}
/// <summary>
/// Writes the specified QualitativeSequence in FastQ format to the file.
/// </summary>
/// <param name="stream">Stream to write to</param>
/// <param name="qualitativeSequence">QualitativeSequence to write.</param>
public void Format(Stream stream, IQualitativeSequence qualitativeSequence)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (qualitativeSequence == null)
{
throw new ArgumentNullException("qualitativeSequence");
}
using (var writer = stream.OpenWrite())
{
this.Format(writer, qualitativeSequence);
}
}
public void TestFormatingString()
{
string str =
@"@SRR002012.1 Oct4:5:1:871:340 length=26
GGCGCACTTACACCCTACATCCATTG
+SRR002012.1 Oct4:5:1:871:340 length=26
IIIIG1?II;IIIII1IIII1%.I7I
";
StringReader sr = new StringReader(str);
FastQParser parser = new FastQParser();
IQualitativeSequence seq = parser.ParseOne(sr);
FastQFormatter formatter = new FastQFormatter();
string formatterStr = formatter.FormatString(seq);
Assert.AreEqual(str, formatterStr);
}
/// <summary>
/// General method to validate FastQ Formatter.
/// <param name="nodeName">xml node name.</param>
/// <param name="fileExtension">Different temporary file extensions</param>
/// </summary>
private void ValidateFastQFormatter(string nodeName, FastQFileParameters fileExtension)
{
// Gets the expected sequence from the Xml
string filePath = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode);
string expectedQualitativeSequence = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.ExpectedSequenceNode);
string expectedSequenceId = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.SequenceIdNode);
string tempFileName = Path.GetTempFileName();
// Parse a FastQ file using parseOne method.
var fastQParserObj = new FastQParser();
using (fastQParserObj.Open(filePath))
{
IQualitativeSequence oneSequence = fastQParserObj.ParseOne();
// Format Parsed Sequence to temp file with different extension.
var fastQFormatter = new FastQFormatter();
using (fastQFormatter.Open(tempFileName))
{
fastQFormatter.Format(oneSequence);
}
string parsedValue;
string parsedId;
var fastQParserObjTemp = new FastQParser();
using (fastQParserObjTemp.Open(tempFileName))
{
oneSequence = fastQParserObjTemp.Parse().First();
parsedValue = oneSequence.ConvertToString();
parsedId = oneSequence.ID;
}
// Validate qualitative parsing temporary file.
Assert.AreEqual(expectedQualitativeSequence, parsedValue);
Assert.AreEqual(expectedSequenceId, parsedId);
ApplicationLog.WriteLine(string.Format("FastQ Formatter BVT: The FASTQ sequence '{0}' validation after Write() and Parse() is found to be as expected.",
parsedValue));
ApplicationLog.WriteLine(string.Format("FastQ Formatter BVT: The FASTQ sequence '{0}' validation after Write() and Parse() is found to be as expected.",
parsedId));
File.Delete(tempFileName);
}
}
public void TestFastQWhenParsingOneOfMany()
{
// parse
ISequenceParser parser = new FastQParser();
string filepath = @"TestUtils\FASTQ\SRR002012_5.fastq";
ISequence seq = parser.ParseOne(filepath);
Assert.IsNotNull(seq);
FastQParser fqParser = new FastQParser();
fqParser.AutoDetectFastQFormat = false;
fqParser.FastqType = FastQFormatType.Sanger;
IQualitativeSequence qualSeq = fqParser.ParseOne(filepath);
Assert.IsNotNull(qualSeq);
((FastQParser)parser).Dispose();
}
/// <summary>
/// Convert quality values to string array
/// </summary>
/// <param name="sequence">Sequence which has the quality values</param>
/// <param name="maxColumns">Max number of columns to write to</param>
/// <returns>string array with quality values</returns>
public static string[,] FastQQualityValuesToRange(IQualitativeSequence sequence, int maxColumns)
{
int rowCount = (int)Math.Ceiling((decimal)sequence.Scores.Length / (decimal)maxColumns);
int columnCount = sequence.Count > maxColumns ? maxColumns : sequence.Count;
string[,] rangeData = new string[rowCount, columnCount];
int count = 0;
for (int row = 0; row < rowCount; row++)
{
for (int col = 0; col < columnCount && count < sequence.Scores.Length; col++, count++)
{
rangeData[row, col] = sequence.Scores[count].ToString();
}
}
return(rangeData);
}
public void TestFastQWhenParsingString()
{
string str =
@"@SRR002012.1 Oct4:5:1:871:340 length=26
GGCGCACTTACACCCTACATCCATTG
+SRR002012.1 Oct4:5:1:871:340 length=26
IIIIG1?II;IIIII1IIII1%.I7I
";
StringReader sr = new StringReader(str);
ISequenceParser parser = new FastQParser();
ISequence seq = parser.ParseOne(sr);
sr = new StringReader(str);
FastQParser fqParser = new FastQParser();
fqParser.AutoDetectFastQFormat = false;
fqParser.FastqType = FastQFormatType.Sanger;
IQualitativeSequence qualSeq = fqParser.ParseOne(sr);
}
public void TestDefaultFastQFormatType()
{
QualitativeSequence qualSeq = new QualitativeSequence(Alphabets.DNA);
Assert.AreEqual(qualSeq.Type, FastQFormatType.Illumina);
string str =
@"@Seq1
GGCGCACTTACACCCTACATCCATTG
+
ABCDEFGHIJKLMNOPQRSTUVWZYZ
";
StringReader sr = new StringReader(str);
FastQParser parser = new FastQParser();
IQualitativeSequence seq = parser.ParseOne(sr);
Assert.AreEqual(seq.Type, FastQFormatType.Illumina);
}
/// <summary>
/// Writes an IQualitativeSequence to a FASTQ file in the location specified by the writer.
/// </summary>
/// <param name="sequence">The QualitativeSequence to format.</param>
/// <param name="writer">The TextWriter used to write the formatted sequence text.</param>
public override void Format(ISequence sequence, TextWriter writer)
{
if (sequence == null)
{
throw new ArgumentNullException(Resource.ParameterNameSequence);
}
IQualitativeSequence qualSequence = sequence as IQualitativeSequence;
if (qualSequence == null)
{
throw new ArgumentException(Resource.FastQ_InvalidSequence);
}
if (writer == null)
{
throw new ArgumentNullException(Resource.ParameterNameWriter);
}
Format(qualSequence, writer);
}
/// <summary>
/// Gets quality values from specified sequence.
/// </summary>
/// <param name="sequence">Sequence object.</param>
private static byte[] GetQualityValue(ISequence sequence)
{
byte[] qualityValues = new byte[sequence.Count];
IQualitativeSequence qualitativeSeq = sequence as IQualitativeSequence;
if (qualitativeSeq != null)
{
qualityValues = qualitativeSeq.Scores;
}
for (int i = 0; i < qualityValues.Length; i++)
{
if (qualitativeSeq == null)
{
qualityValues[i] = 0xFF;
}
else
{
qualityValues[i] -= 33;
}
}
return(qualityValues);
}
/// <summary>
/// Write out a sequence to the given stream writer.
/// </summary>
/// <param name="writer"></param>
/// <param name="qualitativeSequence"></param>
private void Format(StreamWriter writer, IQualitativeSequence qualitativeSequence)
{
string header = qualitativeSequence.ID;
const string LengthStr = " length=";
if (qualitativeSequence.ID.Contains(LengthStr))
{
int startIndex = qualitativeSequence.ID.LastIndexOf(LengthStr, StringComparison.OrdinalIgnoreCase);
header = header.Substring(0, startIndex + 8) + qualitativeSequence.Count;
}
// Write to stream.
writer.WriteLine("@" + header);
byte[] sequenceBytes = qualitativeSequence.ToArray();
writer.WriteLine(Encoding.UTF8.GetString(sequenceBytes, 0, sequenceBytes.Length));
writer.WriteLine("+" + header);
byte[] qualityValues = QualitativeSequence.ConvertEncodedQualityScore(qualitativeSequence.FormatType, this.FormatType, qualitativeSequence.GetEncodedQualityScores());
writer.WriteLine(Encoding.UTF8.GetString(qualityValues, 0, qualityValues.Length));
if (this.AutoFlush)
{
writer.Flush();
}
}
/// <summary>
/// Writes an ISequenceAlignment to the location specified by the writer.
/// </summary>
/// <param name="sequenceAlignment">The sequence alignment to format.</param>
/// <param name="writer">The TextWriter used to write the formatted sequence alignment text.</param>
public void Format(ISequenceAlignment sequenceAlignment, TextWriter writer)
{
if (sequenceAlignment == null)
{
throw new ArgumentNullException(Resource.ParameterNameSequenceAlignment);
}
if (writer == null)
{
throw new ArgumentNullException(Resource.ParameterNameWriter);
}
#region Write alignment header
SAMAlignmentHeader header = sequenceAlignment.Metadata[Helper.SAMAlignmentHeaderKey] as SAMAlignmentHeader;
if (header != null)
{
WriteHeader(header, writer);
}
#endregion
#region Write aligned sequences
foreach (IAlignedSequence alignedSequence in sequenceAlignment.AlignedSequences)
{
SAMAlignedSequenceHeader alignedHeader = alignedSequence.Metadata[Helper.SAMAlignedSequenceHeaderKey] as SAMAlignedSequenceHeader;
if (alignedHeader == null)
{
throw new ArgumentException(Resource.SAM_AlignedSequenceHeaderMissing);
}
StringBuilder alignmentLine = new StringBuilder();
alignmentLine.Append(alignedHeader.QName);
alignmentLine.Append("\t");
alignmentLine.Append((int)alignedHeader.Flag);
alignmentLine.Append("\t");
alignmentLine.Append(alignedHeader.RName);
alignmentLine.Append("\t");
alignmentLine.Append(alignedHeader.Pos);
alignmentLine.Append("\t");
alignmentLine.Append(alignedHeader.MapQ);
alignmentLine.Append("\t");
alignmentLine.Append(alignedHeader.CIGAR);
alignmentLine.Append("\t");
if (string.Compare(alignedHeader.MRNM, alignedHeader.RName, StringComparison.InvariantCultureIgnoreCase) == 0)
{
alignmentLine.Append("=");
}
else
{
alignmentLine.Append(alignedHeader.MRNM);
}
alignmentLine.Append("\t");
alignmentLine.Append(alignedHeader.MPos);
alignmentLine.Append("\t");
alignmentLine.Append(alignedHeader.ISize);
alignmentLine.Append("\t");
writer.Write(alignmentLine.ToString());
List <int> dotSymbolIndices = new List <int>(alignedHeader.DotSymbolIndices);
List <int> equalSymbolIndices = new List <int>(alignedHeader.EqualSymbolIndices);
if (alignedSequence.Sequences.Count > 0 && alignedSequence.Sequences[0] != null)
{
ISequence seq = alignedSequence.Sequences[0];
if (seq.Alphabet != Alphabets.DNA)
{
throw new ArgumentException(Resource.SAMFormatterSupportsDNAOnly);
}
for (int i = 0; i < seq.Count; i++)
{
char symbol = seq[i].Symbol;
if (dotSymbolIndices.Count > 0)
{
if (dotSymbolIndices.Contains(i))
{
symbol = '.';
dotSymbolIndices.Remove(i);
}
}
if (equalSymbolIndices.Count > 0)
{
if (equalSymbolIndices.Contains(i))
{
symbol = '=';
equalSymbolIndices.Remove(i);
}
}
writer.Write(symbol);
}
writer.Write("\t");
IQualitativeSequence qualSeq = seq as IQualitativeSequence;
if (qualSeq != null)
{
writer.Write(ASCIIEncoding.ASCII.GetString(qualSeq.Scores));
}
else
{
writer.Write("*");
}
}
else
{
writer.Write("*");
writer.Write("\t");
writer.Write("*");
}
foreach (SAMOptionalField field in alignedHeader.OptionalFields)
{
writer.Write("\t");
writer.Write(field.Tag);
writer.Write(":");
writer.Write(field.VType);
writer.Write(":");
writer.Write(field.Value);
}
writer.WriteLine();
}
#endregion
writer.Flush();
}
/// <summary>
/// General method to Invalidate FastQ Parser.
/// <param name="nodeName">xml node name.</param>
/// <param name="param">FastQ Formatter different parameters</param>
/// </summary>
void InValidateFastQFormatter(FastQFormatParameters param)
{
// Gets the expected sequence from the Xml
string filepath = _utilityObj._xmlUtil.GetTextValue(
Constants.MultiSeqSangerRnaProNode, Constants.FilePathNode);
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
_utilityObj._xmlUtil.GetTextValue(Constants.MultiSeqSangerRnaProNode,
Constants.FastQFormatType));
// Parse a FastQ file.
using (FastQParser fastQParser = new FastQParser())
{
fastQParser.AutoDetectFastQFormat = true;
fastQParser.FastqType = expectedFormatType;
IQualitativeSequence sequence = null;
sequence = fastQParser.ParseOne(filepath);
FastQFormatter fastQFormatter = new FastQFormatter();
TextWriter txtWriter = null;
switch (param)
{
case FastQFormatParameters.TextWriter:
try
{
fastQFormatter.Format(sequence, null as TextWriter);
Assert.Fail();
}
catch (Exception)
{
ApplicationLog.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
Console.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
}
break;
case FastQFormatParameters.Sequence:
try
{
fastQFormatter.Format(null as ISequence, txtWriter);
Assert.Fail();
}
catch (Exception)
{
ApplicationLog.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
Console.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
}
break;
case FastQFormatParameters.QualitativeSequence:
try
{
fastQFormatter.Format(null as IQualitativeSequence, txtWriter);
Assert.Fail();
}
catch (Exception)
{
ApplicationLog.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
Console.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
}
break;
default:
try
{
fastQFormatter.Format(sequence as QualitativeSequence, null as TextWriter);
Assert.Fail();
}
catch (Exception)
{
ApplicationLog.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
Console.WriteLine(
"FastQ Parser P2 : Successfully validated the exception");
}
break;
}
}
}
/// <summary>
/// This method is not supported since VirtualSequenceList is read-only.
/// </summary>
public void Insert(int index, IQualitativeSequence item)
{
throw new NotSupportedException(Properties.Resource.NotSupportedInVirtualSequence);
}
/// <summary>
/// Determines whether a specific qualitative sequence is in the virtual qualitative sequence list.
/// </summary>
/// <param name="item">The qualitative sequence to locate in the list.</param>
/// <returns>true if the qualitative sequence is found in the list; otherwise, false</returns>
public bool Contains(IQualitativeSequence item)
{
return(IndexOf(item) >= 0);
}
/// <summary>
/// This method is not supported since VirtualSequenceList is read-only.
/// </summary>
public bool Remove(IQualitativeSequence item)
{
throw new NotSupportedException(Properties.Resource.NotSupportedInVirtualSequence);
}
