public void TestFastQWhenParsingOneOfMany()
{
string filepath = @"TestUtils\FASTQ\SRR002012_5.fastq";
// parse
ISequenceParser parser = new FastQParser(filepath);
try
{
ISequence seq = parser.Parse().First();
Assert.IsNotNull(seq);
}
finally
{
parser.Dispose();
}
using (FastQParser fqParser = new FastQParser(filepath))
{
fqParser.AutoDetectFastQFormat = false;
fqParser.FormatType = FastQFormatType.Sanger;
fqParser.Alphabet = Alphabets.DNA;
QualitativeSequence qualSeq = fqParser.Parse().First();
Assert.IsNotNull(qualSeq);
}
}
/// <summary>
/// Writes the specified QualitativeSequence in FastQ format to the file.
/// </summary>
/// <param name="qualitativeSequence">QualitativeSequence to write.</param>
public void Write(QualitativeSequence qualitativeSequence)
{
if (qualitativeSequence == null)
{
throw new ArgumentNullException("qualitativeSequence");
}
if (this.streamWriter == null)
{
throw new InvalidOperationException(Properties.Resource.FileNotOpened);
}
string header = qualitativeSequence.ID;
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.
this.streamWriter.WriteLine("@" + header);
byte[] sequenceBytes = qualitativeSequence.ToArray();
this.streamWriter.WriteLine(UTF8Encoding.UTF8.GetString(sequenceBytes, 0, sequenceBytes.Length));
this.streamWriter.WriteLine("+" + header);
byte[] qualityValues = qualitativeSequence.QualityScores.ToArray();
this.streamWriter.WriteLine(UTF8Encoding.UTF8.GetString(qualityValues, 0, qualityValues.Length));
if (this.AutoFlush)
{
this.streamWriter.Flush();
}
}
public void InvalidateQualSequenceWithNullValue()
{
// Get values from xml.
string expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.AlphabetNullExceptionNode);
string actualError = string.Empty;
string updatedActualError = string.Empty;
QualitativeSequence qualSeq = null;
//create Qualitative sequence by passing null value.
try
{
qualSeq = new QualitativeSequence(null, FastQFormatType.Sanger,
(byte[])null, (byte[])null);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
actualError = ex.Message;
// Validate an expected exception.
updatedActualError = actualError.Replace("\r", "").Replace("\n", "");
Assert.AreEqual(expectedErrorMessage.ToLower(CultureInfo.CurrentCulture),
updatedActualError.ToLower(CultureInfo.CurrentCulture));
Assert.IsNull(qualSeq);
}
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P2: Qualitative Sequence Null exception was validated successfully {0}",
updatedActualError));
}
public void ValidateSangerFormatTypeDnaReverseComplement()
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(Constants.SimpleDnaSangerNode, Constants.FastQFormatType));
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.inputSequenceNode);
string compSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.ComplementQualSeqNode);
string expectedRevCompSeq = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.RevComplement);
string expectedRevSeq = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.ReverseQualSeq);
string inputQuality = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.InputByteArrayNode);
byte[] byteArray = Encoding.UTF8.GetBytes(inputQuality);
QualitativeSequence createdQualitativeSequence =
new QualitativeSequence(alphabet, expectedFormatType,
inputSequence, inputQuality);
ISequence revSeq = createdQualitativeSequence.GetReversedSequence();
ISequence revCompSeq = createdQualitativeSequence.GetReverseComplementedSequence();
ISequence compSeq = createdQualitativeSequence.GetComplementedSequence();
Assert.AreEqual(expectedRevSeq, new string(revSeq.Select(a => (char)a).ToArray()));
Assert.AreEqual(expectedRevCompSeq, new string(revCompSeq.Select(a => (char)a).ToArray()));
Assert.AreEqual(compSequence, new string(compSeq.Select(a => (char)a).ToArray()));
ApplicationLog.WriteLine("Qualitative BVT: Successfully validated Reverse, Complement and ReverseComplement sequence");
}
public void TestConstructorsWithInvalidParameters()
{
QualitativeSequence qualSequence;
try
{
qualSequence = new QualitativeSequence(null);
Assert.Fail();
}
catch (Exception)
{
}
try
{
qualSequence = new QualitativeSequence(
Alphabets.DNA,
FastQFormatType.Sanger,
null as IEncoding,
string.Empty);
Assert.Fail();
}
catch (Exception)
{
}
try
{
qualSequence = new QualitativeSequence(Alphabets.RNA, FastQFormatType.Illumina, "ACTGGA");
Assert.Fail();
}
catch (Exception)
{
}
}
public void ValidateSangerFormatTypeDnaReverseComplement()
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
utilityObj.xmlUtil.GetTextValue(Constants.SimpleDnaSangerNode, Constants.FastQFormatType));
string inputSequence = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.inputSequenceNode);
string compSequence = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.ComplementQualSeqNode);
string expectedRevCompSeq = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.RevComplement);
string expectedRevSeq = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.ReverseQualSeq);
string inputQuality = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.InputByteArrayNode);
byte[] byteArray = Encoding.UTF8.GetBytes(inputQuality);
QualitativeSequence createdQualitativeSequence =
new QualitativeSequence(alphabet, expectedFormatType,
inputSequence, inputQuality);
ISequence revSeq = createdQualitativeSequence.GetReversedSequence();
ISequence revCompSeq = createdQualitativeSequence.GetReverseComplementedSequence();
ISequence compSeq = createdQualitativeSequence.GetComplementedSequence();
Assert.AreEqual(expectedRevSeq, new string(revSeq.Select(a => (char)a).ToArray()));
Assert.AreEqual(expectedRevCompSeq, new string(revCompSeq.Select(a => (char)a).ToArray()));
Assert.AreEqual(compSequence, new string(compSeq.Select(a => (char)a).ToArray()));
ApplicationLog.WriteLine("Qualitative BVT: Successfully validated Reverse, Complement and ReverseComplement sequence");
}
public void QualitativeSequenceClone()
{
QualitativeSequence qualSequence = new QualitativeSequence(Alphabets.RNA, FastQFormatType.Illumina, "ACUGGA", 65);
Assert.AreEqual(qualSequence.Alphabet, Alphabets.RNA);
Assert.IsTrue(qualSequence.IsReadOnly);
Assert.AreEqual(qualSequence.Count, 6);
Assert.AreEqual(qualSequence.Scores.Length, 6);
foreach (byte qualScore in qualSequence.Scores)
{
Assert.AreEqual(qualScore, 65);
}
Assert.AreEqual(qualSequence.ToString(), "ACUGGA");
Assert.AreEqual(qualSequence.Type, FastQFormatType.Illumina);
QualitativeSequence cloneCopy = qualSequence.Clone();
Assert.AreEqual(cloneCopy.Alphabet, Alphabets.RNA);
Assert.IsTrue(cloneCopy.IsReadOnly);
Assert.AreEqual(cloneCopy.Count, 6);
Assert.AreEqual(cloneCopy.Scores.Length, 6);
foreach (byte qualScore in cloneCopy.Scores)
{
Assert.AreEqual(qualScore, 65);
}
Assert.AreEqual(cloneCopy.ToString(), "ACUGGA");
Assert.AreEqual(cloneCopy.Type, FastQFormatType.Illumina);
}
public void ValidateQualititaiveSequenceConstructor()
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSolexaNode, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
utilityObj.xmlUtil.GetTextValue(Constants.SimpleDnaSolexaNode,
Constants.FastQFormatType));
QualitativeSequence createdQualitativeSequence = null;
string inputSequence = utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSolexaNode, Constants.inputSequenceNode);
byte[] qualScores = new byte[inputSequence.Count()];
for (int i = 0; i < inputSequence.Count(); i++)
{
qualScores[i] = (byte)'{';
}
// Create a Qualitative Sequence.
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, encodingObj.GetBytes(inputSequence), qualScores);
string qualSequence = new string(createdQualitativeSequence.Select(a => (char)a).ToArray());
// Validate Qualitative Sequence after addition of Seq Item.
Assert.IsTrue(!string.IsNullOrEmpty(qualSequence));
Assert.AreEqual(inputSequence, qualSequence);
// Logs to the NUnit GUI (Console.Out) window
Console.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence BVT: Qualitative Sequence {0} is as expected.",
qualSequence));
}
public void ConvertIlluminaToSangerAndSolexa()
{
// Gets the actual sequence and the Qual score from the Xml
string illuminaSequence = utilityObj.xmlUtil.GetTextValue(
Constants.IlluminaToSangerAndSolexaNode, Constants.IlluminaSequence);
string illuminaQualScore = utilityObj.xmlUtil.GetTextValue(
Constants.IlluminaToSangerAndSolexaNode, Constants.IlluminaQualScore);
string expectedSangerQualScore = utilityObj.xmlUtil.GetTextValue(
Constants.IlluminaToSangerAndSolexaNode, Constants.SangerQualScore);
string expectedSolexaQualScore = utilityObj.xmlUtil.GetTextValue(
Constants.IlluminaToSangerAndSolexaNode, Constants.SolexaQualScore);
byte[] illuminaSequenceinBytes = Encoding.UTF8.GetBytes(illuminaSequence);
byte[] illuminaQualScoreinBytes = Encoding.UTF8.GetBytes(illuminaQualScore);
byte[] sangerQualScore = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Illumina_v1_3, FastQFormatType.Sanger, illuminaQualScoreinBytes);
string qualSequenceSanger = new string(Encoding.UTF8.GetChars(sangerQualScore));
// Validate converted sanger score.
Assert.AreEqual(expectedSangerQualScore, qualSequenceSanger);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence BVT:Qualitative Sanger score type {0} is as expected.",
sangerQualScore));
byte[] solexaQualScore = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Illumina_v1_3, FastQFormatType.Solexa_Illumina_v1_0, illuminaQualScoreinBytes);
string qualSequenceSolexa = new string(Encoding.UTF8.GetChars(solexaQualScore));
// Validate converted illumina score.
Assert.AreEqual(expectedSolexaQualScore, qualSequenceSolexa);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence BVT:Qualitative Solexa format type {0} is as expected.",
illuminaQualScore));
}
public static void ParseQualityNSequence(SAMAlignedSequence alignedSeq, IAlphabet alphabet, byte[] sequencedata, byte[] qualitydata, bool validate = true)
{
if (alignedSeq == null)
{
throw new ArgumentNullException("alignedSeq");
}
if (sequencedata == null || sequencedata.Length == 0)
{
throw new ArgumentNullException("sequencedata");
}
if (qualitydata == null || qualitydata.Length == 0)
{
throw new ArgumentNullException("qualitydata");
}
bool isQualitativeSequence = true;
string message = string.Empty;
FastQFormatType fastQType = QualityFormatType;
if (sequencedata.Length == 1 && sequencedata[0] == AsteriskAsByte)
{
return;
}
if (qualitydata.Length == 1 && qualitydata[0] == AsteriskAsByte)
{
isQualitativeSequence = false;
}
if (isQualitativeSequence)
{
// Check for sequence length and quality score length.
if (sequencedata.Length != qualitydata.Length)
{
string message1 = string.Format(CultureInfo.CurrentCulture, Properties.Resource.FastQ_InvalidQualityScoresLength, alignedSeq.QName);
message = string.Format(CultureInfo.CurrentCulture, Properties.Resource.IOFormatErrorMessage, Properties.Resource.SAM_NAME, message1);
Trace.Report(message);
throw new FileFormatException(message);
}
}
ISequence sequence = null;
if (isQualitativeSequence)
{
QualitativeSequence qualSeq = new QualitativeSequence(alphabet, fastQType, sequencedata, qualitydata, validate);
qualSeq.ID = alignedSeq.QName;
sequence = qualSeq;
}
else
{
sequence = new Sequence(alphabet, sequencedata, validate);
sequence.ID = alignedSeq.QName;
}
alignedSeq.QuerySequence = sequence;
}
public void GetStringSequenceTest()
{
ISequence seqObj = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Sanger,
"GGCGCACTTACACCCTACATCCATTG", "IIIIG1?II;IIIII1IIII1%.I7I");
string expected = "GGCGCACTTACACCCTACATCCATTG";
string actual;
actual = BioHelper.GetStringSequence(seqObj);
Assert.AreEqual(expected, actual);
}
public void TestGetPhredQualityScore()
{
// Validate using SangerFormat.
List <int> pharedQualityScores = GetPharedQualityScoresForSanger();
byte[] encodedSangerQualityScores = GetSangerEncodedQualityScores(pharedQualityScores);
byte[] symbols = GetSymbols(encodedSangerQualityScores.Length);
QualitativeSequence qualSeq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Sanger, symbols, encodedSangerQualityScores);
for (int i = 0; i < qualSeq.Count; i++)
{
Assert.AreEqual(pharedQualityScores[i], qualSeq.GetPhredQualityScore(i));
}
// Validate using illumina v1.3 .
pharedQualityScores = GetPharedQualityScoresForIllumina_v1_3();
byte[] encodedIllumina_v1_3_QualityScores = GetIllumina_v1_3_EncodedQualityScores(pharedQualityScores);
symbols = GetSymbols(encodedIllumina_v1_3_QualityScores.Length);
qualSeq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Illumina_v1_3, symbols, encodedIllumina_v1_3_QualityScores);
for (int i = 0; i < qualSeq.Count; i++)
{
Assert.AreEqual(pharedQualityScores[i], qualSeq.GetPhredQualityScore(i));
}
// Validate using illumina v1.5
pharedQualityScores = GetPharedQualityScoresForIllumina_v1_5();
byte[] encodedIllumina_v1_5_QualityScores = GetIllumina_v1_5_EncodedQualityScores(pharedQualityScores);
symbols = GetSymbols(encodedIllumina_v1_5_QualityScores.Length);
qualSeq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Illumina_v1_5, symbols, encodedIllumina_v1_5_QualityScores);
for (int i = 0; i < qualSeq.Count; i++)
{
Assert.AreEqual(pharedQualityScores[i], qualSeq.GetPhredQualityScore(i));
}
// Validate using illumina v1.8
pharedQualityScores = GetPharedQualityScoresForIllumina_v1_8();
byte[] encodedIllumina_v1_8_QualityScores = GetIllumina_v1_8_EncodedQualityScores(pharedQualityScores);
symbols = GetSymbols(encodedIllumina_v1_8_QualityScores.Length);
qualSeq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Illumina_v1_8, symbols, encodedIllumina_v1_8_QualityScores);
for (int i = 0; i < qualSeq.Count; i++)
{
Assert.AreEqual(pharedQualityScores[i], qualSeq.GetPhredQualityScore(i));
}
// Validate using illumina v1.0 .
List <int> solexaQualityScores = GetSolexaQualityScoresForIllumina_v1_0();
byte[] encodedIllumina_v1_0_QualityScores = GetIllumina_v1_0_EncodedQualityScores(solexaQualityScores);
symbols = GetSymbols(encodedIllumina_v1_0_QualityScores.Length);
qualSeq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Solexa_Illumina_v1_0, symbols, encodedIllumina_v1_0_QualityScores);
for (int i = 0; i < qualSeq.Count; i++)
{
Assert.AreEqual(solexaQualityScores[i], qualSeq.GetSolexaQualityScore(i));
}
}
public void TestConvertFromSolexaToSanger()
{
byte[] sangerScores;
byte[] solexaScores = new byte[1];
solexaScores[0] = (byte)59;
sangerScores = QualitativeSequence.ConvertFromSolexaToSanger(solexaScores);
Assert.IsNotNull((object)sangerScores);
Assert.AreEqual <int>(1, sangerScores.Length);
Assert.AreEqual <byte>((byte)33, sangerScores[0]);
}
/// <summary>
/// Gets default encoded quality scores.
/// </summary>
/// <param name="formatType">Fastq format type.</param>
/// <param name="length">No of quality scores required.</param>
public static string GetDefaultEncodedQualityScores(FastQFormatType formatType, int length)
{
char[] encodedQualityScores = new char[length];
for (int i = 0; i < length; i++)
{
encodedQualityScores[i] = (char)QualitativeSequence.GetDefaultQualScore(formatType);
}
return(new string(encodedQualityScores));
}
public void TestConvertFromSolexaToSanger()
{
byte[] bs;
byte[] bs1 = new byte[1];
bs1[0] = (byte)59;
bs = QualitativeSequence.ConvertFromSolexaToSanger(bs1);
Assert.IsNotNull((object)bs);
Assert.AreEqual <int>(1, bs.Length);
Assert.AreEqual <byte>((byte)33, bs[0]);
}
public void TestConvertFromSolexa_Illumina_v1_0ToSanger()
{
byte[] sangerScores;
byte[] solexaScores = new byte[1];
solexaScores[0] = (byte)59;
sangerScores = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Solexa_Illumina_v1_0, FastQFormatType.Sanger, solexaScores);
Assert.IsNotNull((object)sangerScores);
Assert.AreEqual(1, sangerScores.Length);
Assert.AreEqual((byte)33, sangerScores[0]);
}
public void FastqTrimRegex1()
{
QualitativeSequence seqObj = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Sanger, "GGGCCCGATTACATTTAAA", "ABCABCIIIIIIIABCABC");
QualitativeSequence expected = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Sanger, "GGGCCCTTTAAA", "ABCABCABCABC");
TrimByRegex target = new TrimByRegex(new FastQParser(), new FastQFormatter(), new FastQFormatter(), "GATTACA");
ISequence actual = target.Trim(seqObj);
Assert.AreEqual(BioHelper.GetStringSequence(expected), BioHelper.GetStringSequence(actual));
Assert.AreEqual(BioHelper.GetEncodedQualityScoreStringSequence(expected), BioHelper.GetEncodedQualityScoreStringSequence(actual as QualitativeSequence));
}
/// <summary>
/// Initializes a new instance of the <see cref="Bio.IO.PacBio.PacBioCCSRead"/> class. From an initially parsed BAM file.
/// </summary>
/// <param name="s">S.</param>
public PacBioCCSRead(SAMAlignedSequence s)
{
/* TODO: Converting from binary to string and back is beyond silly...
* no performance hit worth worrying about at present, but in the future it might be worth
* going directly from binary to the type rather than through string intermediates */
foreach (var v in s.OptionalFields)
{
if (v.Tag == "sn")
{
var snrs = v.Value.Split(',').Skip(1).Select(x => Convert.ToSingle(x)).ToArray();
SnrA = snrs [0];
SnrC = snrs [1];
SnrG = snrs [2];
SnrT = snrs [3];
}
else if (v.Tag == "zm")
{
HoleNumber = (int)Convert.ToInt32(v.Value);
}
else if (v.Tag == "pq")
{
// This tag is now deprecated by the rq tag
ReadQuality = Convert.ToSingle(v.Value);
}
else if (v.Tag == "rq" && ReadQuality < 0)
{
ReadQuality = Convert.ToSingle(v.Value);
}
else if (v.Tag == "za")
{
AvgZscore = (float)Convert.ToSingle(v.Value);
}
else if (v.Tag == "rs")
{
statusCounts = v.Value.Split(',').Skip(1).Select(x => Convert.ToInt32(x)).ToArray();
}
else if (v.Tag == "np")
{
NumPasses = Convert.ToInt32(v.Value);
}
else if (v.Tag == "RG")
{
ReadGroup = v.Value;
}
else if (v.Tag == "zs")
{
ZScores = v.Value.Split(',').Skip(1).Select(x => Convert.ToSingle(x)).ToArray();
}
}
// TODO: We should use String.Intern here, but not available in PCL...
// Movie = String.Intern(s.QuerySequence.ID.Split ('/') [0]);
Movie = s.QuerySequence.ID.Split('/') [0];
Sequence = s.QuerySequence as QualitativeSequence;
}
public void TestConvertFromSangerToSolexa()
{
byte[] solexaScores;
byte[] sangerScores = new byte[2];
sangerScores[0] = (byte)34;
sangerScores[1] = (byte)34;
solexaScores = QualitativeSequence.ConvertFromSangerToSolexa(sangerScores);
Assert.IsNotNull((object)solexaScores);
Assert.AreEqual <int>(2, solexaScores.Length);
Assert.AreEqual <byte>((byte)59, solexaScores[0]);
Assert.AreEqual <byte>((byte)59, solexaScores[1]);
}
public void TestConvertFromIlluminaToSolexa()
{
byte[] solexaScores;
byte[] illuminaScores = new byte[2];
illuminaScores[0] = (byte)65;
illuminaScores[1] = (byte)65;
solexaScores = QualitativeSequence.ConvertFromIlluminaToSolexa(illuminaScores);
Assert.IsNotNull((object)solexaScores);
Assert.AreEqual <int>(2, solexaScores.Length);
Assert.AreEqual <byte>((byte)59, solexaScores[0]);
Assert.AreEqual <byte>((byte)59, solexaScores[1]);
}
public void TestConvertFromIlluminaToSanger()
{
byte[] sangerScores;
byte[] illuminaScores = new byte[2];
illuminaScores[0] = (byte)64;
illuminaScores[1] = (byte)64;
sangerScores = QualitativeSequence.ConvertFromIlluminaToSanger(illuminaScores);
Assert.IsNotNull((object)sangerScores);
Assert.AreEqual <int>(2, sangerScores.Length);
Assert.AreEqual <byte>((byte)33, sangerScores[0]);
Assert.AreEqual <byte>((byte)33, sangerScores[1]);
}
public void TestConvertFromIlluminaToSanger()
{
byte[] bs;
byte[] bs1 = new byte[2];
bs1[0] = (byte)64;
bs1[1] = (byte)64;
bs = QualitativeSequence.ConvertFromIlluminaToSanger(bs1);
Assert.IsNotNull((object)bs);
Assert.AreEqual <int>(2, bs.Length);
Assert.AreEqual <byte>((byte)33, bs[0]);
Assert.AreEqual <byte>((byte)33, bs[1]);
}
public void FastqTrimNullTest()
{
ISequence seqObj = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Sanger,
"GGCGCACTTACACCCTACATCCATTG", "IIIIG1?II;IIIII1IIII1%.I7I");
double trimLength = seqObj.Count + 1;
bool trimFromStart = false;
TrimByLength target = new TrimByLength(new FastQParser(), new FastQFormatter(), null, trimLength, trimFromStart);
ISequence actual;
actual = target.Trim(seqObj);
Assert.IsNull(actual);
}
public void TestConvertFromIllumina_v1_3ToSolexa_Illumina_v1_0()
{
byte[] solexaScores;
byte[] illuminaScores = new byte[2];
illuminaScores[0] = (byte)65;
illuminaScores[1] = (byte)65;
solexaScores = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Illumina_v1_3, FastQFormatType.Solexa_Illumina_v1_0, illuminaScores);
Assert.IsNotNull((object)solexaScores);
Assert.AreEqual(2, solexaScores.Length);
Assert.AreEqual((byte)59, solexaScores[0]);
Assert.AreEqual((byte)59, solexaScores[1]);
}
public void TestConvertFromSangerToIllumina_v1_3()
{
byte[] illuminaScores;
byte[] sangerScores = new byte[2];
sangerScores[0] = (byte)33;
sangerScores[1] = (byte)33;
illuminaScores = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Sanger, FastQFormatType.Illumina_v1_3, sangerScores);
Assert.IsNotNull((object)illuminaScores);
Assert.AreEqual <int>(2, illuminaScores.Length);
Assert.AreEqual <byte>((byte)64, illuminaScores[0]);
Assert.AreEqual <byte>((byte)64, illuminaScores[1]);
}
public void TestConvertFromSangerToSolexa_Illumina_v1_0()
{
byte[] solexaScores;
byte[] sangerScores = new byte[2];
sangerScores[0] = (byte)34;
sangerScores[1] = (byte)34;
solexaScores = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Sanger, FastQFormatType.Solexa_Illumina_v1_0, sangerScores);
Assert.IsNotNull((object)solexaScores);
Assert.AreEqual <int>(2, solexaScores.Length);
Assert.AreEqual <byte>((byte)59, solexaScores[0]);
Assert.AreEqual <byte>((byte)59, solexaScores[1]);
}
public void TestConvertFromIllumina_v1_3ToSanger()
{
byte[] sangerScores;
byte[] illuminaScores = new byte[2];
illuminaScores[0] = (byte)64;
illuminaScores[1] = (byte)64;
sangerScores = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Illumina_v1_3, FastQFormatType.Sanger, illuminaScores);
Assert.IsNotNull((object)sangerScores);
Assert.AreEqual(2, sangerScores.Length);
Assert.AreEqual((byte)33, sangerScores[0]);
Assert.AreEqual((byte)33, sangerScores[1]);
}
/// <summary>
/// Gets the index of a qualitative sequence within the list.
/// Throws a NotSupportedException when attempting to set the position
/// since VirtualSequenceList is read-only.
/// </summary>
/// <param name="index">The zero-based index of the qualitative sequence in the list.</param>
/// <returns>The qualitative sequence found at the specified index.</returns>
public IQualitativeSequence this[int index]
{
get
{
QualitativeSequence virtualQualitativeSequence;
if (_sequenceDictionary.ContainsKey(index))
{
virtualQualitativeSequence = _sequenceDictionary[index].Target as QualitativeSequence;
if (virtualQualitativeSequence != null)
{
return(virtualQualitativeSequence);
}
_sequenceDictionary.Remove(index);
}
SequencePointer pointer = _sidecarProvider[index];
// Get the alphabet from alphabet name.
IAlphabet alphabet = Alphabets.All.Single(A => A.Name.Equals(pointer.AlphabetName));
virtualQualitativeSequence = new QualitativeSequence(alphabet)
{
ID = ((FastQParser)_sequenceParser).GetSequenceID(pointer),
VirtualQualitativeSequenceProvider =
new FileVirtualQualitativeSequenceProvider(_sequenceParser, pointer)
};
if (pointer.IndexOffsets[1] - pointer.IndexOffsets[0] < virtualQualitativeSequence.VirtualQualitativeSequenceProvider.BlockSize)
{
virtualQualitativeSequence.VirtualQualitativeSequenceProvider.BlockSize = (int)(pointer.IndexOffsets[1] - pointer.IndexOffsets[0]);
}
virtualQualitativeSequence.IsReadOnly = CreateSequenceAsReadOnly;
// memory opt : cleanup the weak reference dictionary
if (_sequenceDictionary.Count > 0 && (_sequenceDictionary.Count % MaximumDictionaryLength) == 0)
{
foreach (int key in _sequenceDictionary.Keys.Where(K => _sequenceDictionary[K].IsAlive == false).ToList())
{
_sequenceDictionary.Remove(key);
}
}
_sequenceDictionary.Add(index, new WeakReference(virtualQualitativeSequence, false));
return(virtualQualitativeSequence);
}
set
{
throw new NotSupportedException(Properties.Resource.NotSupportedInVirtualSequence);
}
}
public void TestGetDefaultQualScore()
{
byte b;
b = QualitativeSequence.GetDefaultQualScore(FastQFormatType.Sanger);
Assert.AreEqual((byte)93, b);
b = QualitativeSequence.GetDefaultQualScore(FastQFormatType.Solexa_Illumina_v1_0);
Assert.AreEqual((byte)124, b);
b = QualitativeSequence.GetDefaultQualScore(FastQFormatType.Illumina_v1_3);
Assert.AreEqual((byte)124, b);
}
public void TestGetMaxQualScore()
{
byte b;
b = QualitativeSequence.GetMaxEncodedQualScore(FastQFormatType.Solexa_Illumina_v1_0);
Assert.AreEqual((byte)126, b);
b = QualitativeSequence.GetMaxEncodedQualScore(FastQFormatType.Sanger);
Assert.AreEqual((byte)126, b);
b = QualitativeSequence.GetMaxEncodedQualScore(FastQFormatType.Illumina_v1_3);
Assert.AreEqual((byte)126, b);
}
/// <summary>
/// Gets encoded quality scores.
/// </summary>
public byte[] GetEncodedQualityScores()
{
QualitativeSequence seq = QuerySequence as QualitativeSequence;
if (seq != null)
{
return(seq.GetEncodedQualityScores());
}
else
{
return(new byte[0]);
}
}
/// <summary>
/// Gets Phred base quality scores.
/// </summary>
public int[] GetQualityScores()
{
QualitativeSequence seq = QuerySequence as QualitativeSequence;
if (seq != null)
{
return(seq.GetPhredQualityScores());
}
else
{
return(new int[0]);
}
}
/// <summary>
/// General method to validate Index of Qualitative Sequence Items.
/// <param name="nodeName">xml node name.</param>
/// <param name="indexParam">Different Qualitative Sequence parameters.</param>
/// </summary>
void ValidateGeneralQualitativeSeqItemIndices(string nodeName, QualitativeSequenceParameters indexParam)
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
QualitativeSequence createdQualitativeSequence = null;
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.inputSequenceNode);
string expectedFirstItemIdex = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.FirstItemIndex);
string expectedLastItemIdex = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.LastItemIndex);
string expectedGapIndex = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.IndexOfGap);
long lastItemIndex;
long index;
// Create a qualitative Sequence.
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, inputSequence,
Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length));
// Get a Index of qualitative sequence items
switch (indexParam)
{
case QualitativeSequenceParameters.IndexOfNonGap:
index = createdQualitativeSequence.IndexOfNonGap();
// Validate Qualitative sequence item indices.
Assert.AreEqual(index, Convert.ToInt32(expectedFirstItemIdex, (IFormatProvider)null));
break;
case QualitativeSequenceParameters.IndexOfNonGapWithParam:
index = createdQualitativeSequence.IndexOfNonGap(5);
// Validate Qualitative sequence item indices.
Assert.AreEqual(index, Convert.ToInt32(expectedGapIndex, (IFormatProvider)null));
break;
case QualitativeSequenceParameters.LastIndexOf:
lastItemIndex = createdQualitativeSequence.LastIndexOfNonGap();
// Validate Qualitative sequence item indices.
Assert.AreEqual(lastItemIndex, Convert.ToInt32(expectedLastItemIdex, (IFormatProvider)null));
break;
case QualitativeSequenceParameters.LastIndexOfWithPam:
lastItemIndex = createdQualitativeSequence.LastIndexOfNonGap(5);
// Validate Qualitative sequence item indices.
Assert.AreEqual(lastItemIndex, Convert.ToInt32(expectedGapIndex, (IFormatProvider)null));
break;
default:
break;
}
// Logs to the VSTest GUI window
ApplicationLog.WriteLine("Qualitative Sequence P1 : Qualitative SequenceItems indices validation completed successfully.");
}
/// <summary>
/// General method to validate default score for different FastQ
/// format with different sequence.
/// <param name="nodeName">xml node name.</param>
/// <param name="parameters">Different Qualitative Score method parameter.</param>
/// </summary>
void ValidateFastQDefaultScores(string nodeName, QualitativeSequenceParameters parameters)
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.inputSequenceNode);
string expectedMaxScore = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DefualtMaxScore);
string expectedMinScore = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.DefaultMinScore);
QualitativeSequence createdQualitativeSequence = null;
string qualityScoresString = Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length);
byte[] expectedMaxScores = Utility.GetEncodedQualityScores((byte)int.Parse(expectedMaxScore, null as IFormatProvider), inputSequence.Length);
byte[] expectedMinScores = Utility.GetEncodedQualityScores((byte)int.Parse(expectedMinScore, null as IFormatProvider), inputSequence.Length);
int i = 0;
switch (parameters)
{
case QualitativeSequenceParameters.DefaultScoreWithAlphabets:
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, inputSequence,
qualityScoresString);
// Validate default score.
i = 0;
foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualitativeScore,
(byte)(qualityScoresString[i]));
i++;
}
// Log VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
qualityScoresString[0]));
break;
case QualitativeSequenceParameters.DefaultScoreWithSequence:
createdQualitativeSequence = new QualitativeSequence(alphabet,
expectedFormatType, inputSequence,
qualityScoresString);
i = 0;
// Validate default score.
foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualitativeScore,
(byte)(qualityScoresString[i]));
i++;
}
// Log VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
qualityScoresString[0]));
break;
case QualitativeSequenceParameters.MaxDefaultScore:
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence),
expectedMaxScores);
i = 0;
// Validate default maximum score.
foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualitativeScore,
expectedMaxScores[i]);
i++;
}
// Log VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P1:Qualitative Sequence Maximum score {0} is as expected.",
QualitativeSequence.GetMaxEncodedQualScore(expectedFormatType)));
break;
case QualitativeSequenceParameters.MinDefaultScore:
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence),
expectedMinScores);
i = 0;
// Validate default minimum score.
foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualitativeScore,
expectedMinScores[i]);
i++;
}
// Log VSTest GUI.
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence Minimum score {0} is as expected.",
QualitativeSequence.GetMinEncodedQualScore(expectedFormatType)));
break;
default:
break;
}
}
public void InvalidateQualSequenceWithEmptySequence()
{
QualitativeSequence qualSeq = new QualitativeSequence(
Alphabets.DNA, FastQFormatType.Sanger, "", "");
Assert.IsNotNull(qualSeq);
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P2: Qualitative empty Sequence was validated successfully {0}",
qualSeq));
}
/// <summary>
/// General method to validate creation of Qualitative sequence.
/// <param name="nodeName">xml node name.</param>
/// <param name="parameters">Different Qualitative Sequence parameters.</param>
/// </summary>
void GeneralQualitativeSequence(
string nodeName, QualitativeSequenceParameters parameters)
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
QualitativeSequence createdQualitativeSequence = null;
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.inputSequenceNode);
string expectedSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequenceNode);
string expectedSequenceCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.QSequenceCount);
string inputScoreforIUPAC = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.MaxScoreNode);
string inputQuality = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InputByteArrayNode);
byte[] byteArray = Encoding.UTF8.GetBytes(inputQuality);
int index = 0;
// Create and validate Qualitative Sequence.
switch (parameters)
{
case QualitativeSequenceParameters.Score:
createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
inputSequence, Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length));
// Validate score
foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualScore, Convert.ToInt32(inputScoreforIUPAC, (IFormatProvider)null));
}
break;
case QualitativeSequenceParameters.ByteArray:
createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
Encoding.UTF8.GetBytes(inputSequence), byteArray);
// Validate score
foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualScore, Convert.ToInt32(byteArray[index], (IFormatProvider)null));
index++;
}
break;
default:
break;
}
// Validate createdSequence qualitative sequence.
Assert.IsNotNull(createdQualitativeSequence);
Assert.AreEqual(createdQualitativeSequence.Alphabet, alphabet);
Assert.AreEqual(createdQualitativeSequence.ConvertToString(), expectedSequence);
Assert.AreEqual(createdQualitativeSequence.Count.ToString((IFormatProvider)null), expectedSequenceCount);
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence {0} is as expected.", createdQualitativeSequence));
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence Score {0} is as expected.", createdQualitativeSequence.GetEncodedQualityScores()));
Assert.AreEqual(createdQualitativeSequence.FormatType, expectedFormatType);
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative format type {0} is as expected.", createdQualitativeSequence.FormatType));
}
public void ValidateQualititaiveSequenceConstructor()
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSolexaNode, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(Constants.SimpleDnaSolexaNode,
Constants.FastQFormatType));
QualitativeSequence createdQualitativeSequence = null;
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSolexaNode, Constants.inputSequenceNode);
byte[] qualScores = new byte[inputSequence.Count()];
for (int i = 0; i < inputSequence.Count(); i++)
{
qualScores[i] = (byte)'{';
}
// Create a Qualitative Sequence.
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence), qualScores);
string qualSequence = new string(createdQualitativeSequence.Select(a => (char)a).ToArray());
// Validate Qualitative Sequence after addition of Seq Item.
Assert.IsTrue(!string.IsNullOrEmpty(qualSequence));
Assert.AreEqual(inputSequence, qualSequence);
// Logs to the VSTest GUI
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT: Qualitative Sequence {0} is as expected.", qualSequence));
}
public void TestQualitativeSequenceToString()
{
byte[] seqData = new byte[4];
seqData[0] = (byte)'A';
seqData[1] = (byte)'T';
seqData[2] = (byte)'C';
seqData[3] = (byte)'G';
byte[] qualityScores = new byte[4];
qualityScores[0] = (byte)'A';
qualityScores[1] = (byte)'A';
qualityScores[2] = (byte)'A';
qualityScores[3] = (byte)'B';
QualitativeSequence seq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Illumina_v1_3, seqData, qualityScores);
string actualString = seq.ToString().Replace("\r\n", Environment.NewLine);
string expectedString = "ATCG\r\nAAAB".Replace("\r\n", Environment.NewLine);
Assert.AreEqual(actualString, expectedString);
}
void GeneralQualitativeSequence(
string nodeName, QualitativeSequenceParameters parameters)
{
//// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
string expectedScore = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedScore);
QualitativeSequence createdQualitativeSequence = null;
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.inputSequenceNode);
string expectedSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ExpectedSequenceNode);
string expectedSequenceCount = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.QSequenceCount);
string inputQuality = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InputByteArrayNode);
Byte[] inputScoreArray = Encoding.UTF8.GetBytes(inputQuality);
// Create and validate Qualitative Sequence.
switch (parameters)
{
case QualitativeSequenceParameters.Score:
createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
inputSequence, inputQuality);
int count = 0;
// Validate score
foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualScore, inputScoreArray[count]);
count++;
}
break;
case QualitativeSequenceParameters.ByteArray:
byte[] scoreValue = Encoding.UTF8.GetBytes(inputSequence);
int index = 0;
createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
scoreValue, inputScoreArray);
// Validate score
foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
{
Assert.AreEqual(qualScore, inputScoreArray[index]);
index++;
}
break;
default:
break;
}
string qualitativeSequence = new string(createdQualitativeSequence.Select(a => (char)a).ToArray());
// Validate createdSequence qualitative sequence.
Assert.IsNotNull(createdQualitativeSequence);
Assert.AreEqual(alphabet, createdQualitativeSequence.Alphabet);
Assert.AreEqual(expectedSequence, qualitativeSequence);
Assert.AreEqual(expectedSequenceCount, createdQualitativeSequence.Count.ToString((IFormatProvider)null));
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT:Qualitative Sequence {0} is as expected.", qualitativeSequence));
Assert.AreEqual(expectedScore, createdQualitativeSequence.GetEncodedQualityScores().Count().ToString((IFormatProvider)null));
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT:Qualitative Sequence Score {0} is as expected.", createdQualitativeSequence.Count().ToString((IFormatProvider)null)));
Assert.AreEqual(expectedFormatType, createdQualitativeSequence.FormatType);
ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT:Qualitative format type {0} is as expected.", createdQualitativeSequence.FormatType));
}
public void ConvertSolexaToSangerAndIllumina()
{
// Gets the actual sequence and the Qual score from the Xml
string solexaSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SolexaToSangerAndIlluminaNode, Constants.SolexaSequence);
string expectedSangerSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SolexaToSangerAndIlluminaNode, Constants.SangerSequence);
string expectedIlluminaSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SolexaToSangerAndIlluminaNode, Constants.IlluminaSequence);
string solexaQualScore = this.utilityObj.xmlUtil.GetTextValue(
Constants.SolexaToSangerAndIlluminaNode, Constants.SolexaQualScore);
string expectedSangerQualScore = this.utilityObj.xmlUtil.GetTextValue(
Constants.SolexaToSangerAndIlluminaNode, Constants.SangerQualScore);
string expectedIlluminaQualScore = this.utilityObj.xmlUtil.GetTextValue(
Constants.SolexaToSangerAndIlluminaNode, Constants.IlluminaQualScore);
byte[] byteValue = Encoding.UTF8.GetBytes(solexaQualScore);
string sangerQualScore = null;
string illuminaQualScore = null;
byte[] qualScores = new byte[solexaSequence.Count()];
for (int i = 0; i < solexaSequence.Count(); i++)
{
qualScores[i] = (byte)'{';
}
Byte[] solexaSequenceinBytes = Encoding.UTF8.GetBytes(solexaSequence);
// Create a Solexa qualitative sequence.
QualitativeSequence solexaQualSequence = new QualitativeSequence(Alphabets.DNA,
FastQFormatType.Solexa_Illumina_v1_0, solexaSequenceinBytes, byteValue);
// Convert Solexa to Sanger.
QualitativeSequence sangerQualSequence = solexaQualSequence.ConvertTo(
FastQFormatType.Sanger);
var scores = sangerQualSequence.GetEncodedQualityScores();
sangerQualScore = Encoding.UTF8.GetString(scores, 0, scores.Length);
Assert.AreEqual(expectedSangerQualScore, sangerQualScore);
Assert.AreEqual(new string(sangerQualSequence.Select(a => (char)a).ToArray()), expectedSangerSequence);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence BVT:Qualitative Sanger score type {0} is as expected.",
sangerQualScore));
// Convert Solexa to Illumina.
QualitativeSequence illuminaQualSequence =
solexaQualSequence.ConvertTo(FastQFormatType.Illumina_v1_3);
scores = illuminaQualSequence.GetEncodedQualityScores();
illuminaQualScore = Encoding.UTF8.GetString(scores, 0, scores.Length);
Assert.AreEqual(expectedIlluminaQualScore, illuminaQualScore);
string illuminaQualseq=new string(illuminaQualSequence.Select(a => (char)a).ToArray());
// Validate converted illumina score.
Assert.AreEqual(illuminaQualScore, expectedIlluminaQualScore);
Assert.AreEqual(illuminaQualseq, expectedIlluminaSequence);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence BVT:Qualitative Illumina score type {0} is as expected.",
illuminaQualScore));
}
public void InvalidateQualitativeSeqCtor()
{
// Get Input values from xml config file.
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.QualitativeSequenceInsertSeqItemNode,
Constants.inputSequenceNode);
string QualScoreError = this.utilityObj.xmlUtil.GetTextValue(
Constants.QualitativeSequenceInsertSeqItemNode,
Constants.NullExceptionError);
string actualError = null;
QualitativeSequence seq = null;
// Create a qual sequence.
try
{
seq = new QualitativeSequence(Alphabets.DNA,
FastQFormatType.Sanger, inputSequence, null);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
actualError = ex.Message;
}
finally
{
if (seq != null)
((IDisposable)seq).Dispose();
}
}
/// <summary>
/// General method to create a Qualitative sequence.
/// <param name="nodeName">xml node name of diferent FastQ format.</param>
/// </summary>
private QualitativeSequence CreateQualitativeSequence(string nodeName)
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.AlphabetNameNode));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
QualitativeSequence createdQualitativeSequence = null;
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.inputSequenceNode);
string inputQuality = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.InputByteArrayNode);
byte[] byteArray = Encoding.UTF8.GetBytes(inputQuality);
// Create a Qualitative Sequence.
createdQualitativeSequence = new QualitativeSequence(
alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence), byteArray);
return createdQualitativeSequence;
}
public void ConvertSangerToSolexaAndIllumina()
{
// Gets the actual sequence and the Qual score from the Xml
string sangerSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SangerToSolexaAndIlluminaNode, Constants.SangerSequence);
string expectedSolexaSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SangerToSolexaAndIlluminaNode, Constants.SolexaSequence);
string expectedIlluminaSequence = this.utilityObj.xmlUtil.GetTextValue(
Constants.SangerToSolexaAndIlluminaNode, Constants.IlluminaSequence);
string sangerQualScore = this.utilityObj.xmlUtil.GetTextValue(
Constants.SangerToSolexaAndIlluminaNode, Constants.SangerQualScore);
string expectedSolexaQualScore = this.utilityObj.xmlUtil.GetTextValue(
Constants.SangerToSolexaAndIlluminaNode, Constants.SolexaQualScore);
string expectedIlluminaQualScore = this.utilityObj.xmlUtil.GetTextValue(
Constants.SangerToSolexaAndIlluminaNode, Constants.IlluminaQualScore);
string solexaQualScore = null;
string illuminaQualScore = null;
byte[] scoreValue = Encoding.UTF8.GetBytes(sangerQualScore);
// Create a Sanger qualitative sequence.
QualitativeSequence sangerQualSequence = new QualitativeSequence(Alphabets.DNA,
FastQFormatType.Sanger, sangerSequence, sangerQualScore);
// Convert Sanger to Solexa.
QualitativeSequence solexaQualSequence = sangerQualSequence.ConvertTo(
FastQFormatType.Solexa_Illumina_v1_0);
byte[] sangerToSolexa = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Sanger, FastQFormatType.Solexa_Illumina_v1_0, scoreValue);
var scores = solexaQualSequence.GetEncodedQualityScores();
solexaQualScore = Encoding.UTF8.GetString(scores, 0, scores.Length);
// Validate converted solexa score.
string qualSequence = new string(Encoding.UTF8.GetChars(sangerToSolexa));
Assert.AreEqual(expectedSolexaQualScore, qualSequence);
Assert.AreEqual(solexaQualScore, expectedSolexaQualScore);
string solexaQualString=new string(solexaQualSequence.Select(a => (char)a).ToArray());
Assert.AreEqual(solexaQualString,expectedSolexaSequence);
ApplicationLog.WriteLine(string.Format(null,
"Qualitative Sequence BVT:Qualitative Solexa score type {0} is as expected.",
solexaQualScore));
// Convert Sanger to Illumina.
QualitativeSequence illuminaQualSequence = sangerQualSequence.ConvertTo(
FastQFormatType.Illumina_v1_3);
scores = illuminaQualSequence.GetEncodedQualityScores();
illuminaQualScore = Encoding.UTF8.GetString(scores, 0, scores.Length);
byte[] sangerToIllumina = QualitativeSequence.ConvertEncodedQualityScore(FastQFormatType.Sanger, FastQFormatType.Illumina_v1_3, scoreValue);
string illuminaQualSeq = new string(illuminaQualSequence.Select(a => (char)a).ToArray());
//// Validate converted illumina score.
Assert.AreEqual(illuminaQualScore, expectedIlluminaQualScore);
Assert.AreEqual(illuminaQualSeq, expectedIlluminaSequence);
string sangerToIlluminaString = new string(Encoding.UTF8.GetChars(sangerToIllumina));
Assert.AreEqual(expectedIlluminaQualScore, sangerToIlluminaString);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence BVT:Qualitative Illumina score type {0} is as expected.",
illuminaQualScore));
}
/// <summary>
/// General method to invalidate creation of Qualitative sequence
/// with invalid qual score..
/// <param name="nodeName">Name of the Format type xml node.</param>
/// <param name="errorMessage">Error message xml node name.</param>
/// <param name="qualPam">Qualitative sequence constructor paramter.</param>
/// </summary>
void InValidateQualSequence(string nodeName, string errorMessage,
QualitativeSequenceParameters qualPam)
{
// Get values from xml.
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
string expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(
nodeName, errorMessage).Replace("FORMATTYPE", expectedFormatType.ToString());
string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.inputSequenceNode);
string actualError = string.Empty;
string updatedActualError = string.Empty;
QualitativeSequence qualSeq = null;
byte[] scoreArray = { 65, 64, 66, 68, 69, 67, 65, 65, 65, 65, 65,
200, 3, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 4 };
switch (qualPam)
{
case QualitativeSequenceParameters.FormatType:
//Try to create Qualitative sequence by invalid Quality score
try
{
qualSeq = new QualitativeSequence(Alphabets.DNA, expectedFormatType,
Encoding.UTF8.GetBytes(inputSequence), (byte[])null);
Assert.Fail();
}
catch (ArgumentException ex)
{
actualError = ex.Message;
// Validate an expected exception.
updatedActualError = actualError.Replace("\r", "").Replace("\n", "");
Assert.AreEqual(expectedErrorMessage.ToLower(CultureInfo.CurrentCulture),
updatedActualError.ToLower(CultureInfo.CurrentCulture));
}
break;
case QualitativeSequenceParameters.ByteArray:
//Try to create Qualitative sequence by invalid Quality score
try
{
qualSeq = new QualitativeSequence(Alphabets.DNA, expectedFormatType,
Encoding.UTF8.GetBytes(inputSequence), scoreArray);
Assert.Fail();
}
catch (ArgumentException ex)
{
actualError = ex.Message;
// Validate an expected exception.
updatedActualError = actualError.Replace("\r", "").Replace("\n", "");
Assert.AreEqual(expectedErrorMessage.ToLower(CultureInfo.CurrentCulture),
updatedActualError.ToLower(CultureInfo.CurrentCulture));
}
break;
default:
break;
}
// Log to VSTest GUI.
Assert.IsNull(qualSeq);
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P2: Qualitative Sequence Invalid score exception was validated successfully {0}",
updatedActualError));
}
public void ValidateQualitativeSequenceToString()
{
var seqData = new byte[4];
seqData[0] = (byte) 'A';
seqData[1] = (byte) 'T';
seqData[2] = (byte) 'C';
seqData[3] = (byte) 'G';
var qualityScores = new byte[4];
qualityScores[0] = (byte) 'A';
qualityScores[1] = (byte) 'A';
qualityScores[2] = (byte) 'A';
qualityScores[3] = (byte) 'B';
var seq = new QualitativeSequence(Alphabets.DNA,
FastQFormatType.Illumina_v1_3, seqData, qualityScores);
string actualString = seq.ToString();
string expectedString = "ATCG\nAAAB"; // This is dangerously platform specific
Assert.AreEqual(expectedString, actualString);
}
public void InvalidateQualSequenceWithInvalidChars()
{
// Get values from xml.
string expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(
Constants.SimpleDnaSangerNode, Constants.InvalidAlphabetErrorMessage);
string actualError = string.Empty;
string updatedActualError = string.Empty;
QualitativeSequence qualSeq = null;
//Try creating Qualitative sequence by passing invalid seq chars.
try
{
qualSeq = new QualitativeSequence(Alphabets.DNA, FastQFormatType.Sanger, "AGTZ",
Utility.GetDefaultEncodedQualityScores(FastQFormatType.Sanger,4));
Assert.Fail();
}
catch (ArgumentException ex)
{
actualError = ex.Message;
// Validate an expected exception.
updatedActualError = actualError.Replace("\r", "").Replace("\n", "");
Assert.AreEqual(expectedErrorMessage.ToLower(CultureInfo.CurrentCulture),
updatedActualError.ToLower(CultureInfo.CurrentCulture));
Assert.IsNull(qualSeq);
}
// Log to VSTest GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Qualitative Sequence P2: Qualitative Sequence Null exception was validated successfully {0}",
updatedActualError));
}
/// <summary>
/// General method to validate FastQ formatting
/// Qualitative Sequence by passing TextWriter as a parameter
/// <param name="nodeName">xml node name.</param>
/// </summary>
private void ValidateFastQFormatByFormattingQualSeqeunce(string nodeName)
{
// Gets the actual sequence and the alphabet from the Xml
IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(nodeName, Constants.AlphabetNameNodeV2));
FastQFormatType expectedFormatType = Utility.GetFastQFormatType(utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
string qualSequence = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.ExpectedSequenceNode);
string expectedQualitativeSequence = utilityObj.xmlUtil.GetTextValue(nodeName, Constants.ExpectedSequenceNode);
string qualityScores = "";
int i;
for (i = 0; i < qualSequence.Length; i++)
qualityScores = qualityScores + "}";
byte[] seq = Encoding.UTF8.GetBytes(qualSequence);
byte[] qScore = Encoding.UTF8.GetBytes(qualityScores);
string tempFileName = Path.GetTempFileName();
// Create a Qualitative Sequence.
var qualSeq = new QualitativeSequence(alphabet, expectedFormatType, seq, qScore);
var formatter = new FastQFormatter();
using (formatter.Open(tempFileName))
{
formatter.Format(qualSeq);
formatter.Close();
var fastQParserObj = new FastQParser();
using (fastQParserObj.Open(tempFileName))
{
// Read the new file and validate Sequences.
var seqsNew = fastQParserObj.Parse();
var firstSequence = seqsNew.First();
// Validate qualitative Sequence upon parsing FastQ file.
Assert.AreEqual(expectedQualitativeSequence, firstSequence.ConvertToString());
Assert.IsTrue(string.IsNullOrEmpty(firstSequence.ID));
ApplicationLog.WriteLine(string.Format("FastQ Parser P1: The FASTQ sequence '{0}' validation after Parse() is found to be as expected.", firstSequence));
}
File.Delete(tempFileName);
}
}
