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 ReadMultipleFromStreamAsync_ShouldProduceExpectedOutputForOneSequence()
{
Stream stream = string.Join(Environment.NewLine, ">lcl|123", "ATCG", "AAAA").ToStream();
IList <Sequence> multiFASTAFileData = (await SequenceStreamReader.ReadMultipleFromStreamAsync(stream)).ToList();
Assert.IsNotNull(multiFASTAFileData);
Assert.AreEqual(1, multiFASTAFileData.Count);
Sequence sequence = multiFASTAFileData[0];
Assert.IsNotNull(sequence);
Header header = sequence.Header;
Assert.IsNotNull(header);
Assert.AreEqual(1, header.Items.Count);
LocalIdentifier identifier = header.Items[0] as LocalIdentifier;
Assert.IsNotNull(identifier);
Assert.AreEqual("lcl", identifier.Code);
Assert.AreEqual("123", identifier.Value);
NucleicAcidSequence data = (NucleicAcidSequence)sequence.Data;
Assert.AreEqual("ATCGAAAA", data.Characters);
}
public void Constructor_ShouldRejectNullData()
{
var identifier = new LocalIdentifier("value");
var header = new Header(identifier);
_ = new Sequence(header, null);
}
public void Parse_ShouldProduceExpectedOutputForLines()
{
IEnumerable <string> inputLines = new string[] {
">lcl|123",
"ATCG",
"AAAA"
};
Sequence sequence = Sequence.Parse(inputLines);
Assert.IsNotNull(sequence);
Header header = sequence.Header;
Assert.IsNotNull(header);
Assert.AreEqual(1, header.Items.Count);
LocalIdentifier identifier = header.Items[0] as LocalIdentifier;
Assert.IsNotNull(identifier);
Assert.AreEqual("lcl", identifier.Code);
Assert.AreEqual("123", identifier.Value);
NucleicAcidSequence data = (NucleicAcidSequence)sequence.Data;
Assert.AreEqual("ATCGAAAA", data.Characters);
}
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 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 Parse_ShouldParseLocalIdentifier()
{
var expected = new LocalIdentifier("123");
var actual = IdentifierParser.Parse("lcl|123") as LocalIdentifier;
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Code, actual.Code);
Assert.AreEqual(expected.Value, actual.Value);
}
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 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 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_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 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 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 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 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 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 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 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();
}
public void Parse_ShouldProduceExpectedOutputForString()
{
string inputString = ">lcl|123" + Environment.NewLine + "ATCG" + Environment.NewLine + "AAAA";
Sequence sequence = Sequence.Parse(inputString);
Assert.IsNotNull(sequence);
Header header = sequence.Header;
Assert.IsNotNull(header);
Assert.AreEqual(1, header.Items.Count);
LocalIdentifier identifier = header.Items[0] as LocalIdentifier;
Assert.IsNotNull(identifier);
Assert.AreEqual("lcl", identifier.Code);
Assert.AreEqual("123", identifier.Value);
NucleicAcidSequence data = (NucleicAcidSequence)sequence.Data;
Assert.AreEqual("ATCGAAAA", data.Characters);
}
public void ReadSingleFromStream_ShouldThrowForStreamWithTwoSequences()
{
Stream stream = string.Join(Environment.NewLine, ">lcl|123", "ATCG", "AAAA", "", ">lcl|456", "TTTT", "CCCC").ToStream();
Sequence sequence = SequenceStreamReader.ReadSingleFromStream(stream);
Assert.IsNotNull(sequence);
Header header = sequence.Header;
Assert.IsNotNull(header);
Assert.AreEqual(1, header.Items.Count);
LocalIdentifier identifier = header.Items[0] as LocalIdentifier;
Assert.IsNotNull(identifier);
Assert.AreEqual("lcl", identifier.Code);
Assert.AreEqual("123", identifier.Value);
NucleicAcidSequence data = (NucleicAcidSequence)sequence.Data;
Assert.AreEqual("ATCGAAAA", data.Characters);
}
public void ReadMultipleFromStream_ShouldProduceExpectedOutputForTwoSequences()
{
Stream stream = string.Join(Environment.NewLine, ">lcl|123", "ATCG", "AAAA", "", ">lcl|456", "TTTT", "CCCC").ToStream();
IList <Sequence> multiFASTAFileData = SequenceStreamReader.ReadMultipleFromStream(stream).ToList();
Assert.IsNotNull(multiFASTAFileData);
Assert.AreEqual(2, multiFASTAFileData.Count);
{
Sequence sequence = multiFASTAFileData[0];
Assert.IsNotNull(sequence);
Header header = sequence.Header;
Assert.IsNotNull(header);
Assert.AreEqual(1, header.Items.Count);
LocalIdentifier identifier = header.Items[0] as LocalIdentifier;
Assert.IsNotNull(identifier);
Assert.AreEqual("lcl", identifier.Code);
Assert.AreEqual("123", identifier.Value);
NucleicAcidSequence data = (NucleicAcidSequence)sequence.Data;
Assert.AreEqual("ATCGAAAA", data.Characters);
}
{
Sequence sequence = multiFASTAFileData[1];
Assert.IsNotNull(sequence);
Header header = sequence.Header;
Assert.IsNotNull(header);
Assert.AreEqual(1, header.Items.Count);
LocalIdentifier identifier = header.Items[0] as LocalIdentifier;
Assert.IsNotNull(identifier);
Assert.AreEqual("lcl", identifier.Code);
Assert.AreEqual("456", identifier.Value);
NucleicAcidSequence data = (NucleicAcidSequence)sequence.Data;
Assert.AreEqual("TTTTCCCC", data.Characters);
}
}
public override string ToString()
{
return(LocalIdentifier.ToString());
}
public void Code_ShouldReturnCorrectValue()
{
Identifier identifier = new LocalIdentifier(Value);
Assert.AreEqual(Code, identifier.Code);
}
public void ToString_ShouldFormatCorrectly()
{
Identifier identifier = new LocalIdentifier(Value);
Assert.AreEqual($"{Code}|{Value}", identifier.ToString());
}
public async Task <LocalBeatmaps> GetLocalBeatmaps(LocalBeatmaps cachedLocalBeatmaps = null)
{
LocalBeatmaps localBeatmaps = cachedLocalBeatmaps is null ? new LocalBeatmaps() : new LocalBeatmaps(cachedLocalBeatmaps);
List <string> songs = Directory.GetDirectories(SongsPath).ToList();
foreach (LocalBeatmap beatmap in localBeatmaps.Maps.ToList())
{
string song = songs.FirstOrDefault(x => new DirectoryInfo(x).Name.Split(" ")[0] == beatmap.Identifier.Value);
if (song != null)
{
songs.Remove(song);
}
}
for (int i = 0; i < songs.Count; i++)
{
if (i > 0 && i % 10 == 0)
{
localBeatmaps.LastPage++;
}
}
foreach (string songFolder in songs)
{
string infoFile = Path.Combine(songFolder, "info.dat");
if (!File.Exists(infoFile))
{
continue;
}
string[] folderName = new DirectoryInfo(songFolder).Name.Split(" ");
LocalIdentifier identifier = folderName.Length == 1 ? new LocalIdentifier(false, folderName[0]) : new LocalIdentifier(true, folderName[0]);
string json = await File.ReadAllTextAsync(infoFile);
LocalBeatmap beatmap = JsonConvert.DeserializeObject <LocalBeatmap>(json);
beatmap.Identifier = identifier;
beatmap.FolderPath = songFolder;
string coverImagePath = Path.Combine(songFolder, beatmap.CoverImageFilename);
if (File.Exists(coverImagePath))
{
beatmap.CoverImagePath = coverImagePath;
}
else
{
if (beatmap.Errors is null)
{
beatmap.Errors = new List <string>();
}
beatmap.Errors.Add($"The cover image file '{beatmap.CoverImageFilename}' couldn't be found");
}
string songFilePath = Path.Combine(songFolder, beatmap.SongFilename);
if (File.Exists(songFilePath))
{
MediaInfo mediaInfo = ffProbe.GetMediaInfo(songFilePath);
beatmap.Duration = mediaInfo.Duration;
}
else
{
if (beatmap.Errors is null)
{
beatmap.Errors = new List <string>();
}
beatmap.Errors.Add($"The song file '{beatmap.SongFilename}' couldn't be found");
}
foreach (DifficultyBeatmapSet difficultyBeatmapSet in beatmap.DifficultyBeatmapSets)
{
if (!beatmap.Easy && difficultyBeatmapSet.DifficultyBeatmaps.Any(x => x.Difficulty == "Easy"))
{
beatmap.Easy = true;
}
if (!beatmap.Normal && difficultyBeatmapSet.DifficultyBeatmaps.Any(x => x.Difficulty == "Normal"))
{
beatmap.Normal = true;
}
if (!beatmap.Hard && difficultyBeatmapSet.DifficultyBeatmaps.Any(x => x.Difficulty == "Hard"))
{
beatmap.Hard = true;
}
if (!beatmap.Expert && difficultyBeatmapSet.DifficultyBeatmaps.Any(x => x.Difficulty == "Expert"))
{
beatmap.Expert = true;
}
if (!beatmap.ExpertPlus && difficultyBeatmapSet.DifficultyBeatmaps.Any(x => x.Difficulty == "ExpertPlus"))
{
beatmap.ExpertPlus = true;
}
}
_ = Task.Run(async() =>
{
try
{
beatmap.OnlineBeatmap = await GetBeatmap(identifier);
}
catch (Exception e)
{
if (beatmap.Errors is null)
{
beatmap.Errors = new List <string>();
}
if (e.InnerException is null || string.Equals(e.Message, e.InnerException.Message))
{
beatmap.Errors.Add(e.Message);
}
public void Constructor_ShouldRejectNullValue()
{
_ = new LocalIdentifier(null);
}
