public void ToInterleavedLines_ShouldProduceExpectedOutputForNonDefaultLineLength()
{
string inputSequence = "MDSKGSSQKGSRLLLLLVVSNLLLCQGVVSTPVCPNGPGNCQVSLRDLFDRAVMVSHYIHDLSS"
+ "EMFNEFDKRYAQGKGFITMALNSCHTSSLPTPEDKEQAQQTHHEVLMSLILGLLRSWNDPLYHL";
IEnumerable <string> expectedOutputLines = new string[] {
">lcl|123",
"MDSKGSSQ",
"KGSRLLLL",
"LVVSNLLL",
"CQGVVSTP",
"VCPNGPGN",
"CQVSLRDL",
"FDRAVMVS",
"HYIHDLSS",
"EMFNEFDK",
"RYAQGKGF",
"ITMALNSC",
"HTSSLPTP",
"EDKEQAQQ",
"THHEVLMS",
"LILGLLRS",
"WNDPLYHL"
};
Identifier identifier = new LocalIdentifier("123");
Header header = new Header(identifier);
IActualSequence sequence = AminoAcidSequence.Parse(inputSequence);
var singleFASTAFileData = new Sequence(header, sequence);
IEnumerable <string> actualOutputLines = singleFASTAFileData.ToInterleavedLines(8);
CollectionAssert.AreEqual(expectedOutputLines.ToList(), actualOutputLines.ToList());
}
public async Task WriteToInterleavedFileAsync_SingleSequence_ShouldRejectNegativeLineLength()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
await SequenceFileWriter.WriteToInterleavedFileAsync(sequence, Path, -1);
}
public void WriteToInterleavedFile_SingleSequence_ShouldRejectLineLengthOfZero()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
SequenceFileWriter.WriteToInterleavedFile(sequence, Path, 0);
}
public async Task WriteToInterleavedStreamAsync_SingleSequence_ShouldRejectNullStream()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
await SequenceStreamWriter.WriteToInterleavedStreamAsync(sequence, null);
}
public void WriteToSequentialStream_SingleSequence_ShouldRejectNullStream()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
SequenceStreamWriter.WriteToSequentialStream(sequence, null);
}
public async Task WriteToSequentialFileAsync_SingleSequence_ShouldRejectNullPath()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
await SequenceFileWriter.WriteToSequentialFileAsync(sequence, null);
}
public async Task WriteToSequentialFileAsync_MultipleSequences_ShouldRejectNullPath()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
IEnumerable <Sequence> sequences = new Sequence[] { sequence };
await SequenceFileWriter.WriteToSequentialFileAsync(sequences, null);
}
public async Task WriteToInterleavedFileAsync_MultipleSequences_ShouldRejectLineLengthOfZero()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
IEnumerable <Sequence> sequences = new Sequence[] { sequence };
await SequenceFileWriter.WriteToInterleavedFileAsync(sequences, Path, 0);
}
public void WriteToInterleavedFile_MultipleSequences_ShouldRejectNegativeLineLength()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
IEnumerable <Sequence> sequences = new Sequence[] { sequence };
SequenceFileWriter.WriteToInterleavedFile(sequences, Path, -1);
}
public async Task WriteToInterleavedStreamAsync_SingleSequence_ShouldRejectNegativeLineLength()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
var stream = new MemoryStream(new byte[] { }, true);
await SequenceStreamWriter.WriteToInterleavedStreamAsync(sequence, stream, -1);
}
public void WriteToInterleavedStream_SingleSequence_ShouldRejectLineLengthOfZero()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
var stream = new MemoryStream(new byte[] { }, true);
SequenceStreamWriter.WriteToInterleavedStream(sequence, stream, 0);
}
public void WriteToSequentialStream_MultipleSequences_ShouldRejectNullStream()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
IEnumerable <Sequence> sequences = new Sequence[] { sequence };
SequenceStreamWriter.WriteToSequentialStream(sequences, null);
}
public void Parse_ShouldParseAminoAcidSequence()
{
const string aminoAcidSequenceString = "ABCZ";
IActualSequence sequenceData = ActualSequenceParser.Parse(aminoAcidSequenceString);
Assert.IsNotNull(sequenceData);
Assert.IsInstanceOfType(sequenceData, typeof(AminoAcidSequence));
var aminoAcidSequenceData = (AminoAcidSequence)sequenceData;
Assert.AreEqual(aminoAcidSequenceString, aminoAcidSequenceData.Characters);
}
public async Task WriteToInterleavedStreamAsync_MultipleSequences_ShouldRejectLineLengthOfZero()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
var stream = new MemoryStream(new byte[] { }, true);
IEnumerable <Sequence> sequences = new Sequence[] { sequence };
await SequenceStreamWriter.WriteToInterleavedStreamAsync(sequences, stream, 0);
}
public void WriteToInterleavedStream_MultipleSequences_ShouldRejectNegativeLineLength()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
IActualSequence actualSequence = NucleicAcidSequence.Parse("ATCG");
var sequence = new Sequence(header, actualSequence);
var stream = new MemoryStream(new byte[] { }, true);
IEnumerable <Sequence> sequences = new Sequence[] { sequence };
SequenceStreamWriter.WriteToInterleavedStream(sequences, stream, -1);
}
public void Parse_ShouldAssumeParsingAmbiguousSequenceAsNucleicAcidSequence()
{
const string nucleicAcidSequenceString = "ABCD";
IActualSequence sequenceData = ActualSequenceParser.Parse(nucleicAcidSequenceString);
Assert.IsNotNull(sequenceData);
Assert.IsInstanceOfType(sequenceData, typeof(NucleicAcidSequence));
var nucelicAcidSequenceData = (NucleicAcidSequence)sequenceData;
Assert.AreEqual(nucleicAcidSequenceString, nucelicAcidSequenceData.Characters);
}
public void ToInterleavedLines_ShouldRejectLineLengthOfZero()
{
string inputSequence = "MDSKGSSQKGSRLLLLLVVSNLLLCQGVVSTPVCPNGPGNCQVSLRDLFDRAVMVSHYIHDLSS"
+ "EMFNEFDKRYAQGKGFITMALNSCHTSSLPTPEDKEQAQQTHHEVLMSLILGLLRSWNDPLYHL";
Identifier identifier = new LocalIdentifier("123");
Header header = new Header(identifier);
IActualSequence sequence = AminoAcidSequence.Parse(inputSequence);
var singleFASTAFileData = new Sequence(header, sequence);
_ = singleFASTAFileData.ToInterleavedLines(0).ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="Sequence"/> class.
/// </summary>
/// <param name="header">This sequence's header.</param>
/// <param name="data">The actual sequence data.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="header"/> is <see langword="null"/>.
/// -or-
/// <paramref name="data"/> is <see langword="null"/>.
/// </exception>
public Sequence(Header header, IActualSequence data)
{
if (header == null)
{
throw new ArgumentNullException(nameof(header), "The header cannot be null.");
}
if (data == null)
{
throw new ArgumentNullException(nameof(data), "The sequence data cannot be null.");
}
Header = header;
Data = data;
}
private static Sequence ParseBase(IEnumerable <string> lines)
{
try
{
IEnumerable <string> nonBlankLines = lines.Where(line => !string.IsNullOrWhiteSpace(line));
Header header = Header.Parse(nonBlankLines.First());
IActualSequence sequenceData = ActualSequenceParser.Parse(nonBlankLines.Skip(1));
return(new Sequence(header, sequenceData));
}
catch (FormatException ex)
{
throw new FormatException("The collection of sequence lines are not in the correct format.", ex);
}
}
