public void Client()
{
Race race = new Race(new[] {"asdfasdf"}) {TotalFilesExpected = 5};
Output output = new Output(race);
Assert.AreEqual("=[ 0/5 ]=", output.Format("=[ 0/{5,-3:B3} ]="));
Assert.AreEqual("=[ 0/asd ]=", output.Format("=[ 0/asd ]="));
RaceStats raceStats = new RaceStats();
const ulong bytes = 123456789;
raceStats
.AddFileName("a.txt")
.AddCrc32("aabbccdd")
.AddFileUploaded(true)
.AddFileSpeed(100)
.AddFileSize(bytes)
.AddUserName("user1")
.AddGroupName("group1");
race.AddRaceStats(raceStats);
Assert.AreEqual("]-[Complete 123456789MB - 1/5F]-[", output.Format("]-[Complete {7}MB - {6}/{5}F]-["));
Assert.AreEqual("]-[Complete 117MB - 1/5F]-[", output.Format("]-[Complete {8}MB - {6}/{5}F]-["));
Assert.AreEqual("| 1. user1/group1 117MB 100kBit/s 1F |",
output.FormatUserStats(1,
race.GetUserStats() [0],
"| {0,2:B2}. {2,15:B15}/{3,-15:B15} {8,6:B6} {6,5:B5}kBit/s {7,3:B3}F |"));
Assert.AreEqual("| 1. group1 117MB 100kBit/s 1F |",
output.FormatGroupStats(1,
race.GetGroupStats() [0],
"| {0,2:B2}. {3,-15:B15} {7,6:B6} {5,5:B5}kBit/s {6,3:B3}F |"));
Assert.AreEqual("###--------------", output.Format("{14}"), "ProgressBar");
Assert.AreEqual("117MB", bytes.FormatSize(), "FormatBytesUploaded");
}
public void CreateLink()
{
Race race = new Race(ArgsRarPart1);
race.ParseUpload();
TagManager tagManager = new TagManager(race);
const string testlink = "[iNCOMPLETE]-testLink";
tagManager.CreateSymLink(".", testlink);
Assert.IsTrue(Directory.Exists(testlink));
Directory.Delete(testlink);
}
public void RefuseExtension()
{
CleanTestFilesOutput();
Race race = new Race(ArgsBat);
race.ParseUpload();
Assert.AreEqual(".bat", race.CurrentRaceData.FileExtension, "FileExtension");
Assert.AreEqual("file_bat.bat", race.CurrentRaceData.FileName, "FileName");
Assert.AreEqual("Zip", race.CurrentRaceData.DirectoryName, "DirectoryName");
race.Process();
Assert.IsFalse(race.IsValid);
}
public void NoRaceFileZipCorrect()
{
CleanTestFilesOutput();
string[] args = ArgsCorrectZipDeleteFile1;
Race race = new Race(args)
{
SourceFolder = @"..\..\TestFiles\ZipCorrect",
};
race.ParseDelete();
Assert.IsNotNull(race.CurrentRaceData);
Assert.IsTrue(race.CurrentRaceData.RaceType == RaceType.Delete);
Assert.AreEqual(race.CurrentRaceData.FileName, args[2], "FileName missmatch!");
race.ProcessDelete();
}
public void ByYear()
{
Race race = new Race(new[] { "upload", "", "", "" })
{
CurrentRaceData = new CurrentRaceData
{
UploadVirtualPath = "/TestFiles/Mp3/SwingingSafari",
DirectoryName = "SwingingSafari",
},
};
TagLib.File file = TagLib.File.Create(@"..\..\TestFiles\Mp3\SwingingSafari.mp3");
Extensions.SortAudio(race, file);
string root = Misc.PathCombine(Config.AudioSortByYearPath, "2002");
string directory = Misc.PathCombine(root, "SwingingSafari");
Assert.IsTrue(Directory.Exists(directory));
}
public void Format()
{
Race race = new Race(new[] {"upload", @"..\..\TestFiles\Mp3\06-judas_priest-beyond_the_realms_of_death.mp3", "00000000", @"../../TestFiles/Mp3/06-judas_priest-beyond_the_realms_of_death.mp3"});
race.ParseUpload();
const int totalFilesExpected = 123;
race.TotalFilesExpected = totalFilesExpected;
bool isAudioRace = race.IsAudioRace;
Assert.IsTrue(isAudioRace);
Output output = new Output(race);
File file = File.Create(@"..\..\TestFiles\Mp3\06-judas_priest-beyond_the_realms_of_death.mp3");
Assert.AreEqual("06-judas_priest-beyond_the_realms_of_death.mp3", output.Format("{0}", file), "FileName");
Assert.AreEqual("Mp3", output.Format("{1}", file), "DirectoryName");
Assert.AreEqual("NoUser", output.Format("{2}", file), "UserName");
Assert.AreEqual("NoGroup", output.Format("{3}", file), "GroupName");
Assert.AreEqual("/NoPath", output.Format("{4}", file), "UploadVirtualPath");
Assert.AreEqual(totalFilesExpected.ToString(), output.Format("{5}", file), "TotalFilesExpected");
Assert.AreEqual("0", output.Format("{6}", file), "TotalFilesUploaded");
Assert.AreEqual("0", output.Format("{7}", file), "TotalBytesUploaded");
Assert.AreEqual("0", output.Format("{8}", file), "TotalMegaBytesUploaded");
Assert.AreEqual("0B", output.Format("{9}", file), "TotalBytesUploadedFormated");
Assert.AreEqual("0B", output.Format("{10}", file), "TotalBytesExpected");
Assert.AreEqual("1", output.Format("{11}", file), "TotalAvarageSpeed");
Assert.AreEqual("0", output.Format("{12}", file), "TotalUsersRacing");
Assert.AreEqual("0", output.Format("{13}", file), "TotalGroupsRacing");
Assert.AreEqual("-----------------", output.Format("{14}", file), "ProgressBar");
Assert.AreEqual("0%", output.Format("{15}%", file), "PercentComplete");
Assert.AreEqual(Constants.CodeIrcColor, output.Format("{16}", file), "CodeIrcColor");
Assert.AreEqual(Constants.CodeIrcBold, output.Format("{17}", file), "CodeIrcBold");
Assert.AreEqual(Constants.CodeIrcUnderline, output.Format("{18}", file), "CodeIrcUnderline");
Assert.AreEqual(Constants.CodeNewLine, output.Format("{19}", file), "codeNewLine");
Assert.AreEqual("Judas Priest", output.Format("{20}", file), "FirstPerformer");
Assert.AreEqual("A Touch of Evil Live", output.Format("{21}", file), "Album");
Assert.AreEqual("Beyond the Realms of Death", output.Format("{22}", file), "Title");
Assert.AreEqual("Heavy Metal", output.Format("{23}", file), "FirstGenre");
Assert.AreEqual("2009", output.Format("{24}", file), "Year");
Assert.AreEqual("6", output.Format("{25}", file), "Track");
Assert.AreEqual("1", output.Format("{26}", file), "Speed");
Assert.AreEqual("231", output.Format("{27}", file), "AudioBitrate");
Assert.AreEqual("2", output.Format("{28}", file), "AudioChannels");
Assert.AreEqual("44100", output.Format("{29}", file), "AudioSampleRate");
Assert.AreEqual("0", output.Format("{30}", file), "BitsPerSample");
Assert.AreEqual("MPEG Version 1 Audio, Layer 3 VBR", output.Format("{31}", file), "Description");
Assert.AreEqual("Audio", output.Format("{32}", file), "MediaTypes");
Assert.AreEqual("MPEG Version 1 Audio, Layer 3 VBR", output.Format("{33}", file), "Codecs");
Assert.AreEqual("00:06:51", output.Format("{34}", file), "Duration");
}
public void SfvData()
{
Race race = new Race (ArgsSfv);
race.ParseUpload ();
DataParserSfv sfvParser = new DataParserSfv (race);
sfvParser.Parse ();
sfvParser.Process ();
Assert.AreEqual (4, race.TotalFilesExpected, "TotalFilesExpected");
Dictionary<string, string> sfvData = sfvParser.SfvData;
Assert.IsNotNull (sfvData, "sfvData");
Dictionary<string, string> expectedSfvData = new Dictionary<string, string>
{
{"infected.part1.rar", "2e04944c"},
{"infected.part2.rar", "1c7c24a5"},
{"infected.part3.rar", "d5d617e3"},
{"infected.part4.rar", "0edb20ea"}
};
Assert.AreEqual (expectedSfvData, sfvData);
}
public void ZipCorrect()
{
ZipTests zipTests = new ZipTests();
zipTests.ZipRace();
string[] args = ArgsCorrectZipDeleteFile1;
Race race = new Race(args)
{
SourceFolder = @"..\..\TestFiles\ZipCorrect",
};
race.ParseDelete();
Assert.IsNotNull(race.CurrentRaceData);
Assert.IsTrue(race.CurrentRaceData.RaceType == RaceType.Delete);
Assert.AreEqual(race.CurrentRaceData.FileName, args[2], "FileName missmatch!");
race.ProcessDelete();
const int fileSize = 24683;
Assert.AreEqual((UInt64)fileSize * 4, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(5, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(4, race.TotalFilesUploaded, "TotalFilesUploaded");
}
public void CurrentUploadData()
{
Race race = new Race(ArgsRarPart1);
race.ParseUpload();
Assert.AreEqual("Rar", race.CurrentRaceData.DirectoryName, "DirectoryName");
Assert.That(race.CurrentRaceData.DirectoryPath.EndsWith(@"\TestFiles\Rar"), "DirectoryPath");
Assert.That(race.CurrentRaceData.DirectoryParent.EndsWith(@"\TestFiles"), "DirectoryParent");
Assert.AreEqual(".rar", race.CurrentRaceData.FileExtension, "FileExtension");
Assert.AreEqual("infected.part1.rar", race.CurrentRaceData.FileName, "FileName");
Assert.AreEqual(5000, race.CurrentRaceData.FileSize, "FileSize");
Assert.AreEqual("NoGroup", race.CurrentRaceData.GroupName, "GroupName");
Assert.AreEqual(1, race.CurrentRaceData.Speed, "Speed");
Assert.AreEqual("2e04944c", race.CurrentRaceData.UploadCrc, "UploadCrc");
Assert.AreEqual(@"..\..\TestFiles\Rar\infected.part1.rar", race.CurrentRaceData.UploadFile, "UploadFile");
Assert.AreEqual("/TestFiles/Rar/infected.part1.rar", race.CurrentRaceData.UploadVirtualFile, "UploadVirtualFile");
Assert.AreEqual("NoUser", race.CurrentRaceData.UserName, "UserName");
Assert.AreEqual(0, race.CurrentRaceData.Uid, "UID");
Assert.AreEqual(0, race.CurrentRaceData.Gid, "GID");
Assert.AreEqual("/NoPath", race.CurrentRaceData.UploadVirtualPath, "UploadVirtualPath");
}
public void AddRaceStats()
{
Race race = new Race (ArgsRarPart1);
RaceStats raceStats = new RaceStats ();
raceStats
.AddFileName ("a.txt")
.AddCrc32 ("aabbccdd")
.AddFileUploaded (true)
.AddFileSpeed (1000)
.AddFileSize (1000000)
.AddUserName ("user1")
.AddGroupName ("group1");
race.AddRaceStats (raceStats);
Assert.AreEqual(1, race.TotalFilesUploaded, "TotalFilesUploaded");
Assert.AreEqual((UInt64)1000000, race.TotalBytesUploaded, "TotalBytesUploaded");
// Ignored because file was not uploaded
raceStats = new RaceStats();
raceStats
.AddFileName("d.txt")
.AddCrc32("33bbccdd")
.AddFileUploaded(false)
.AddFileSpeed(400)
.AddFileSize(4000000)
.AddUserName("user4")
.AddGroupName("group3");
race.AddRaceStats(raceStats);
Assert.AreEqual(1, race.TotalFilesUploaded, "TotalFilesUploaded");
Assert.AreEqual((UInt64)1000000, race.TotalBytesUploaded, "TotalBytesUploaded");
raceStats = new RaceStats();
raceStats
.AddFileName ("c.txt")
.AddCrc32 ("22bbccdd")
.AddFileUploaded (true)
.AddFileSpeed (300)
.AddFileSize (3000000)
.AddUserName ("user3")
.AddGroupName ("group1");
race.AddRaceStats (raceStats);
Assert.AreEqual(2, race.TotalFilesUploaded, "TotalFilesUploaded");
Assert.AreEqual((UInt64)4000000, race.TotalBytesUploaded, "TotalBytesUploaded");
raceStats = new RaceStats();
raceStats
.AddFileName("b.txt")
.AddCrc32("11bbccdd")
.AddFileUploaded(true)
.AddFileSpeed(200)
.AddFileSize(2000000)
.AddUserName("user2")
.AddGroupName("group2");
race.AddRaceStats(raceStats);
Assert.AreEqual(3, race.TotalFilesUploaded, "TotalFilesUploaded");
Assert.AreEqual ((UInt64) 6000000, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual ((UInt64) 5, race.TotalMegaBytesUploaded, "TotalMegaBytesUploaded");
Assert.AreEqual (2, race.TotalGroupsRacing, "TotalGroupsRacing");
Assert.AreEqual (3, race.TotalUsersRacing, "TotalUsersRacing");
Assert.AreEqual (3, race.GetUserStats ().Count, "GetUserStats");
Assert.AreEqual(2, race.GetGroupStats().Count, "GetGroupStats");
List<RaceStatsUsers> statsUsers = race.GetUserStats();
Assert.That(statsUsers, Is.Ordered.Descending);
//Assert.Sorted(statsUsers, SortOrder.Decreasing);
List<RaceStatsGroups> statsGroups = race.GetGroupStats ();
Assert.That(statsGroups, Is.Ordered.Descending);
//Assert.Sorted(statsGroups, SortOrder.Decreasing);
//Console
foreach (RaceStatsUsers raceStatsUser in statsUsers)
{
Console.WriteLine(raceStatsUser);
}
foreach (RaceStatsGroups raceStatsGroups in statsGroups)
{
Console.WriteLine(raceStatsGroups);
}
}
public void SpeedTest()
{
Race race = new Race(ArgsRarPart1);
race.ParseUpload();
race.CurrentRaceData.UploadVirtualPath = Config.SpeedTestFolder + "asdfsdfsdf";
Assert.IsTrue(race.SpeedTest(), "race.SpeedTest");
}
public void SkipPath()
{
Race race = new Race(ArgsRarPart1);
race.ParseUpload();
Assert.IsFalse(race.VirtualPathMatch(Config.SkipPath), "race.SkipPath");
}
public void ParseRaceData()
{
Race race = new Race(ArgsRarPart1);
race.ParseUpload ();
race.RaceFile = @"..\..\TestFiles\Race\.ioFTPD.race";
DataParser dataParser = new DataParser (race);
dataParser.Parse ();
Assert.AreEqual (4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual (4, race.TotalFilesUploaded, "TotalFilesUploaded");
}
public void ZipRace()
{
CleanTestFilesOutput();
Race race = new Race(ArgsCorrectZipFile1);
race.ParseUpload();
race.Process();
Assert.IsTrue(race.IsValid);
FileInfo fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
const int fileSize = 24683;
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(5, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 5, SeekOrigin.Begin);
Assert.AreEqual("file-000.zip", reader.ReadString(), "FileName");
Assert.AreEqual("00000000", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)fileSize, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)fileSize, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(5, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(1, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsCorrectZipFile2);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(5, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 4, SeekOrigin.Begin);
Assert.AreEqual("file-001.zip", reader.ReadString(), "FileName");
Assert.AreEqual("00000000", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)fileSize, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)fileSize * 2, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(5, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(2, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsCorrectZipFile3);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(5, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 3, SeekOrigin.Begin);
Assert.AreEqual("file-002.zip", reader.ReadString(), "FileName");
Assert.AreEqual("00000000", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)fileSize, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)fileSize * 3, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(5, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(3, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsCorrectZipFile4);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(5, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 2, SeekOrigin.Begin);
Assert.AreEqual("file-003.zip", reader.ReadString(), "FileName");
Assert.AreEqual("00000000", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)fileSize, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)fileSize * 4, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(5, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(4, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsCorrectZipFile5);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(5, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 1, SeekOrigin.Begin);
Assert.AreEqual("file-004.zip", reader.ReadString(), "FileName");
Assert.AreEqual("00000000", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)fileSize, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)fileSize * 5, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(5, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(5, race.TotalFilesUploaded, "TotalFilesUploaded");
}
public void RaceRar()
{
CleanTestFilesOutput ();
UploadSfvFile ();
Race race = new Race (ArgsRarPart1);
race.ParseUpload ();
race.Process ();
FileInfo fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream (fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader (stream))
{
stream.Seek (0, SeekOrigin.Begin);
Assert.AreEqual (4, reader.ReadInt32 (), "Total files count");
stream.Seek (256 * 1, SeekOrigin.Begin);
Assert.AreEqual ("infected.part1.rar", reader.ReadString (), "FileName");
Assert.AreEqual ("2e04944c", reader.ReadString (), "CRC32");
Assert.AreEqual (true, reader.ReadBoolean (), "File was uploaded");
Assert.AreEqual ((UInt64) 5000, reader.ReadUInt64 (), "FileSize");
}
}
Assert.AreEqual((UInt64)5000, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(1, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsRarPart2);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(4, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 2, SeekOrigin.Begin);
Assert.AreEqual("infected.part2.rar", reader.ReadString(), "FileName");
Assert.AreEqual("1c7c24a5", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)5000, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)5000 * 2, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(2, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsRarPart3);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(4, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 3, SeekOrigin.Begin);
Assert.AreEqual("infected.part3.rar", reader.ReadString(), "FileName");
Assert.AreEqual("d5d617e3", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)5000, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)5000 * 3, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(3, race.TotalFilesUploaded, "TotalFilesUploaded");
race = new Race(ArgsRarPart4);
race.ParseUpload();
race.Process();
fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(4, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 4, SeekOrigin.Begin);
Assert.AreEqual("infected.part4.rar", reader.ReadString(), "FileName");
Assert.AreEqual("0edb20ea", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64)2916, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64)5000 * 3 + 2916, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(4, race.TotalFilesUploaded, "TotalFilesUploaded");
}
public void ZipRaceNoDiz()
{
CleanTestFilesOutput();
Race race = new Race(ArgsZipFile1);
race.ParseUpload();
race.Process();
Assert.IsFalse(race.IsValid);
}
public Output(Race race)
{
this.race = race;
}
public TagManager(Race race)
{
this.race = race;
}
protected Race UploadSfvFile()
{
Race race = new Race(ArgsSfv);
race.ParseUpload();
Assert.AreEqual(".sfv", race.CurrentRaceData.FileExtension, "FileExtension");
Assert.AreEqual("infected.sfv", race.CurrentRaceData.FileName, "FileName");
Assert.AreEqual(432, race.CurrentRaceData.FileSize, "FileSize");
Assert.AreEqual("Rar", race.CurrentRaceData.DirectoryName, "DirectoryName");
race.Process();
return race;
}
protected Race UploadSfvFileMp3()
{
Race race = new Race(ArgsSfvMp3);
race.ParseUpload();
Assert.AreEqual(".sfv", race.CurrentRaceData.FileExtension, "FileExtension");
Assert.AreEqual("jozek.Pepek-2009-asd-Ind.sfv", race.CurrentRaceData.FileName, "FileName");
//Assert.AreEqual(554, race.CurrentRaceData.FileSize, "FileSize");
Assert.AreEqual("Mp3", race.CurrentRaceData.DirectoryName, "DirectoryName");
race.Process();
return race;
}
protected Race UploadDizFile()
{
Race race = new Race(ArgsDiz);
race.ParseUpload();
Assert.AreEqual(".diz", race.CurrentRaceData.FileExtension, "FileExtension");
Assert.AreEqual("file_id.diz", race.CurrentRaceData.FileName, "FileName");
Assert.AreEqual(350, race.CurrentRaceData.FileSize, "FileSize");
Assert.AreEqual("Zip", race.CurrentRaceData.DirectoryName, "DirectoryName");
race.Process();
return race;
}
protected Race UploadNfoFile02()
{
Race race = new Race(ArgsNfo02);
race.ParseUpload();
Assert.AreEqual(".nfo", race.CurrentRaceData.FileExtension, "FileExtension");
Assert.AreEqual("Movie02.nfo", race.CurrentRaceData.FileName, "FileName");
Assert.AreEqual("Nfo", race.CurrentRaceData.DirectoryName, "DirectoryName");
race.Process();
return race;
}
public DataParserSfv(Race race)
{
this.race = race;
currentRaceData = race.CurrentRaceData;
fileName = currentRaceData.UploadFile;
}
public void Race()
{
CleanTestFilesOutput();
UploadSfvFileMp3();
Race race = new Race(ArgsMp3File1);
race.ParseUpload();
race.Process();
Output output = new Output(race);
FileInfo fileInfo = new FileInfo(Misc.PathCombine(race.CurrentRaceData.DirectoryPath, Config.FileNameRace));
using (FileStream stream = new FileStream(fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.None))
{
using (BinaryReader reader = new BinaryReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(4, reader.ReadInt32(), "Total files count");
stream.Seek(256 * 1, SeekOrigin.Begin);
Assert.AreEqual("01-jozek.Pepek-2009-asd-Ind.mp3", reader.ReadString(), "FileName");
Assert.AreEqual("2e04944c", reader.ReadString(), "CRC32");
Assert.AreEqual(true, reader.ReadBoolean(), "File was uploaded");
Assert.AreEqual((UInt64) 5000, reader.ReadUInt64(), "FileSize");
}
}
Assert.AreEqual((UInt64) 5000, race.TotalBytesUploaded, "TotalBytesUploaded");
Assert.AreEqual(4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(1, race.TotalFilesUploaded, "TotalFilesUploaded");
Assert.IsFalse(
File.Exists(@"..\..\TestFiles\Mp3\01-jozek.Pepek-2009-asd-Ind.mp3" + Config.FileExtensionMissing),
"01-jozek.Pepek-2009-asd-Ind.mp3" + Config.FileExtensionMissing);
Assert.IsTrue(
Directory.Exists(Misc.PathCombine(race.CurrentRaceData.DirectoryParent, output.Format(Config.TagIncompleteLink))),
"Symlink does not exist!");
race = new Race(ArgsMp3File2);
race.ParseUpload();
race.Process();
output = new Output(race);
Assert.IsFalse(
File.Exists(@"..\..\TestFiles\Mp3\02-jozek.Pepek-2009-asd-Ind.mp3" + Config.FileExtensionMissing),
"02-jozek.Pepek-2009-asd-Ind.mp3" + Config.FileExtensionMissing);
Assert.IsTrue(
Directory.Exists(Misc.PathCombine(race.CurrentRaceData.DirectoryParent, output.Format(Config.TagIncompleteLink))),
"Symlink does not exist!");
race = new Race(ArgsMp3File3);
race.ParseUpload();
race.Process();
output = new Output(race);
Assert.IsFalse(
File.Exists(@"..\..\TestFiles\Mp3\03-jozek.Pepek-2009-asd-Ind(2).mp3" + Config.FileExtensionMissing),
"03-jozek.Pepek-2009-asd-Ind(2).mp3" + Config.FileExtensionMissing);
Assert.IsTrue(
Directory.Exists(Misc.PathCombine(race.CurrentRaceData.DirectoryParent, output.Format(Config.TagIncompleteLink))),
"Symlink does not exist!");
race = new Race(ArgsMp3File4);
race.ParseUpload();
race.Process();
output = new Output(race);
Assert.AreEqual(4, race.TotalFilesExpected, "TotalFilesExpected");
Assert.AreEqual(4, race.TotalFilesUploaded, "TotalFilesUploaded");
Assert.IsFalse(
File.Exists(@"..\..\TestFiles\Mp3\04-jozek.Pepek-2009-asd-Ind(3).mp3" + Config.FileExtensionMissing),
"04-jozek.Pepek-2009-asd-Ind(3).mp3" + Config.FileExtensionMissing);
Assert.IsFalse(
Directory.Exists(Misc.PathCombine(race.CurrentRaceData.DirectoryParent, output.Format(Config.TagIncompleteLink))),
"Symlink not deleted!");
}
public DataParser(Race race)
{
this.race = race;
}
public DataParserDiz(Race race)
{
this.race = race;
currentRaceData = race.CurrentRaceData;
fileName = "file_id.diz";
}
